A Methodology for Making Requests: Official 10 Getting-Started Tips

With the same WorkBuddy, some people get a usable result in one round, while others go back and forth and burn through a pile of credits—the gap usually isn't in the tool but in how you ask, that is, how you write WorkBuddy prompts. The official team has distilled the experience beginners need most into "10 getting-started tips": covering how to make requests, how to control risk, how to improve result quality, and when it's appropriate to hand things off to AI for automatic execution. If you're also wondering how to write task instructions for AI without rework, this lesson breaks these 10 tips down one by one, with official positive and negative examples, so you can reliably turn a "vague idea" into an "executable task".

This is Lesson 1 of "Efficient Workflow", based on WorkBuddy v5.9.3, with content drawn from the official "WorkBuddy 10 Getting-Started Tips" document.

• Haven't seen this series' roadmap yet? Go back to 3.0 Efficient Workflow: From Basic Use to Great Use first
• Not familiar with the basic conversation operations (adding requests, follow-ups, rollback)? Read 2.1 Advanced Conversation: Multi-Round Adjustment, Rollback, and References first

What you'll be able to do after this lesson

• Use the "what to do + what you have + what it should look like" three-element formula to rewrite a vague one-liner into a clear prompt with paths and output format
• Break big tasks like a 50-page report into three rounds of progress, confirming direction each round before continuing, instead of grinding through in one go
• Refine results over multiple rounds using four adjustment methods: directly pointing out problems, restating from a different angle, adding constraints, and switching role perspectives
• Attach an expert identity to a task and feed in reference samples to make output more professional and more stable
• Back up real files before touching them and know where the rollback button is, and only then hand things off to scheduled tasks and remote channels

Your current struggles

• With the same "help me organize this", my colleague gets results in one round while I go back and forth in rework, burning plenty of credits, and the output still isn't usable
• I threw a big task at it all at once, and it output a huge pile of content, yet not a single part satisfied me
• I asked it to modify a document, and only after it finished did I find that content I wanted to keep had been deleted and the formatting was messed up—with no backup

When to use this technique

When you need to:

• Turn a vague idea into a task that WorkBuddy can execute precisely
• Get a first-round result that's close to usable, with less rework and fewer burned credits
• Establish safety boundaries before letting AI touch your real files

And you don't want to:

• Rely on luck every time, with results that vary for unclear reasons
• Have no way back after a file is broken, forced to redo it in tears

🎒 Preparation Before Starting

• Have read 3.0 Efficient Workflow: From Basic Use to Great Use, and know the roadmap of this series' 4 lessons
• Have completed 1.4 Your First Task: From One Sentence to a Deliverable, and know how to create a task, send messages, and find outputs in the results area
• 15 minutes of reading time—ideally open a task while reading and practice with your own work at hand

Core Idea

The official 10 tips revolve around a single fact: WorkBuddy can't read minds.

In the official words: the less information you give, the more chaotic the space it has to work with. So the minimum requirement for making a request is a three-element formula:

What to do + what you have + what it should look like

What to do (the task goal), what you have (the input materials, such as file paths), and what it should look like (output format and constraints). State all three fully, and you can get a nearly usable result in the first round.

On top of that, the 10 tips unfold along "make requests → control risk → improve quality → then let go", and the official team also gave a recommended order for getting started:

#	Tip	One-line takeaway	What it covers
1	Express clearly	What to do + what you have + what it should look like; don't make the AI guess your intent	Making requests
2	Small, fast steps	Break big tasks into small steps and finish one thing at a time	Making requests
3	Multi-round adjustment	The first answer is only a starting point; refine if unsatisfied	Making requests
4	Local first, then remote	Get comfortable on the desktop app before letting it work remotely	Control risk
5	Give it an identity	Attach an expert role for more professional output	Improve quality
6	Give examples	One reference sample beats ten lines of abstract requirements	Improve quality
7	Multiple sessions	Open a different window for each task; don't grind away in a polluted context	Improve quality
8	Backups and version management	Back up files before editing them so you have a way back if things break	Control risk
9	Automation	Scheduled tasks let WorkBuddy keep working	Then let go
10	Laziness + motivation	Outsource mechanical work to AI and use roles and standards to raise the output	Then let go

The officially recommended learning order: **first learn to state requirements clearly → then learn to proceed step by step and iterate over multiple rounds → next get familiar with expert roles, samples, and multitasking → when real files are involved, back up first, then try remote control and automation.**In one sentence: "Stating the task clearly matters more than any technique."

Below, in that order, we'll practice the 10 techniques one by one.

Follow along with me

Step 1: Write a qualified WorkBuddy prompt with the "three-element formula"

Why: Many beginners toss over a vague one-liner and then feel deeply disappointed by the result — the reason is simple: WorkBuddy can't read minds. The more complete the information, the more precisely it executes.

How to do it: Before sending a task, self-check against the three elements — what to do (task goal), what you have (input materials), how it should look (output format and constraints). The official good-vs-bad comparison:

❌ Bad example:
Help me tidy up the meeting notes from last time.

✅ Good example:
Organize the meeting notes in D:/Meeting Minutes/0320 Product Review.docx into a checklist that includes:
1) the conclusion for each agenda item;
2) the corresponding owner and deadline;
3) items flagged as disputed or unresolved.
Output as a table, no opening remarks.

The good example has all three elements: what to do (organize into a checklist), what you have (a specific file path), and how it should look (three content requirements + table output + no opening remarks).

You should see: The good example yields a fully structured table checklist in one round, with no need to rework or re-ask; the bad example produces a generic write-up where the direction is pure guesswork.

• I can flesh out a "help me tidy this up" into an explicit prompt with a path, output format, and constraints

💡 No idea where to start at all?

Official beginner tip: first ask WorkBuddy "I want to do XX — what information do you need from me?" and let it help you sort out the inputs before moving into actual execution.

Step 2: Split a big task into three rounds — small steps, fast iterations

Why: The most common beginner mistake is dumping a huge request all at once — "Translate and summarize this entire 50-page report." The usual result: it outputs a lot of content, but nothing truly satisfies you. A better approach is to break the big task into independent small goals and advance one step at a time.

How to do it: The official 50-page report example, split into three rounds:

Round 1:
Read D:/Reports/2026 AI Industry Report.pdf and extract the 5 most core conclusions,
summarizing each conclusion in one sentence, with the original page number attached.

Round 2:
Based on these 5 conclusions, help me write a 15-page internal briefing outline summarizing industry trends,
focusing on opportunities relevant to our business, plus recommendations and next steps.

Round 3:
The outline looks good — now expand the second page, "Opportunity Analysis," into full PPT page content,
with a note of 50 words or fewer for each opportunity, and send it to my manager.

The benefit of stepping through it (in the official words): at each step you can first confirm the direction is right, and if it drifts, pull it back in time — instead of having to throw out the entire result and redo it at the end.

You should see: At the end of each round you get a checkable intermediate deliverable (5 conclusions → briefing outline → PPT page content), so a wrong direction can be corrected within that round.

• I have split my big task into at least two rounds, confirming before continuing in each round

Step 3: If you're not satisfied, polish over multiple rounds — don't settle it in one

Why: Many users give up as soon as the first result disappoints — that's the biggest waste. The key to AI conversation is back-and-forth polishing: the first round sets the direction, and later rounds gradually narrow and calibrate. The more specific and true-to-life your description, the more easily WorkBuddy can "step into" your real needs.

How to do it: Four common adjustment methods (official list):

Adjustment method	Example
Point out the problem directly	"Too long" "The tone is too formal" "The logic in the third paragraph doesn't hold — rewrite it"
Restate the requirement from a different angle	Replace abstract requirements with a more concrete business scenario
Add constraints	Add requirements about audience, scenario, format, length, etc.
Switch role perspective	Have it think from the standpoint of a boss, customer, product manager, analyst, etc.

The official three-round polishing example for an apology email:

Round 1:
Help me write an apology email to a customer, because the data in the report we delivered last time was wrong.
(It produces a formal, rather long apology letter with an overly serious tone.)

Round 2:
Too formal — the customer is an old friend we've worked with for three years. Make the tone more relaxed, like a WeChat message style,
within 200 words, focusing on the cause of the problem and the fact that it's fixed; no repeated apologies.
(The tone becomes more concise and closer to everyday communication.)

Round 3:
Not bad, but add one line — "Next time before delivery I'll send you a confirmation version first" — at the end.

You can think of the conversation as coaching a very diligent intern who needs feedback — the more willing you are to spell out "what's wrong and what you want," the closer the output will be to what you have in mind. If you want to undo a step during polishing, the rollback, edit, and refresh features covered in 2.1 Advanced Conversation come in handy.

You should see: After two or three rounds of adjustment, the result goes from "unusable" to "almost ready to hand in" — rather than starting over from scratch every round.

• For an unsatisfactory result, I used at least one adjustment method (point out the problem / restate / add constraints / switch perspective) instead of giving up right away

Step 4: Give WorkBuddy an identity and an example

Why: For tasks that are highly professional or have strict output style requirements, description alone often fails to convey the "feel." The official guide offers the two simplest quality-boosting techniques.

Give it an identity (technique 5): WorkBuddy has a built-in "expert" capability that provides preset roles across industries — legal advisor, product manager, data analyst, marketing copywriter, and more. Once you pick a suitable expert, it prioritizes organizing its answer along that role's line of thinking. This is effectively a pre-set layer of "role prompting" that aligns the framing, focus, and terminology with the corresponding field more quickly.

Give examples (technique 6): Verbal description sometimes struggles to express the exact "feel" you want. The least-effort and most effective approach is to hand it a sample you're happy with and tell it: "Follow this." Compared with guessing from scratch, a sample is a very explicit anchor — tone, structure, format, style of expression: with a clear enough reference, the output stays consistent.

How to do it:

• When a task leans toward a specialized field, pick a matching role in the Expert Center (see 3.2 Experts and Expert Teams for the entry point and full usage)
• When you have a past output you're happy with, attach it to the task as a sample: "Write following the style and structure of this one"

You should see: once an identity is attached and examples are given, the terminology, tone, and structure of the output align noticeably more with the domain style you want, and rework count drops.

• I have attached an expert identity to a task, or attached a reference sample saying "follow this one"

Step 5: Open a separate session for each task, and switch to a fresh one when the context goes bad

Why: Stuffing everything into one session lets backgrounds contaminate each other, and things drift further off course the longer you chat. The official advice is to treat each session as an independent workbench.

How to do it:

• Open a different window for different tasks: one window for writing proposals, one for organizing data, one for answering emails—no interference between them, all moving forward in parallel
• When a session gets too long and starts showing "forgetting what was said earlier" or "drifting further off course," don't force it—just start a new task and restate the key background concisely; this is often more effective than repeatedly patching the old context

For state management and search when running multiple tasks in parallel, see 2.2 Task Management: Status, Search, and Bulk Operations.

You should see: each session has a single, clean-context topic; after switching to a new session, it no longer gets led astray by earlier irrelevant content.

• I no longer mix three different things in the same session; when a session goes off track, I open a new task and restate the background

Step 6: Back up files before touching them, and learn to roll back

Why: However capable, WorkBuddy is not absolutely stable every time. The official docs warn that it sometimes "over-edits": deleting content you wanted to keep, scrambling the original formatting, or pushing the direction further and further off—by the time you notice something is wrong, the original version may already be overwritten. The mature way to use it is not to expect it to never make mistakes, but to prepare a rollback plan in advance.

How to do it (three layers of fallback, each backing up the next):

• Back up before changes: Before having it modify a document, proposal, or spreadsheet, make a copy of the original file—even just appending "_backup" or the current date to the filename
• Check the preview first: For operations that change local state, such as batch renaming or file writing, have it show a preview or comparison table first, and execute only after you confirm (safety tip from the official practice case: before making changes, WorkBuddy automatically backs up on the system, and you can also keep an old-vs-new comparison table)
• Roll back via the conversation: In local tasks, hover over one of the messages you sent and click "Roll back"; the conversation and outputs together return to the state before that message. "Edit" and "Refresh" will also pop up a confirmation dialog asking "roll back the output to a previous version?" when outputs have been changed—details of the three operations are in 2.1 Conversation Advanced

You should see: even if it breaks something, you can recover the original file or roll back to a previous output version, and your main deliverable stays unaffected.

• I have a habit of making a backup copy before letting it touch important files, and I know the "Roll back" button appears when hovering over a message

Step 7: Local first, remote later—hand repetitive work to automation

Why: WorkBuddy supports receiving commands remotely via apps like WeChat and QQ, and the setup isn't complicated. But remote control means it acts autonomously where you can't see it—once it executes something beyond expectations, you may not be able to stop it in time. So beginners should first use it on the desktop while watching, figure out how it executes, how it interprets instructions, and where the risk boundaries are, and then gradually let go.

How to do it: the official "local first, remote later" three-step example:

Step 1 (local desktop):
List all files in my D:/Downloads folder, grouped by type.

Step 2 (local desktop):
Move the .pdf files among them to D:/Documents/PDF Archive and the .xlsx files to D:/Documents/Spreadsheets Archive;
leave the rest untouched. Before executing, list the files to be moved for my confirmation.

Step 3 (only consider remote after confirming its judgment is reliable):
From now on, run the same archiving task for me every Friday afternoon.

Step 3 naturally transitions intoautomation (tip 9): through scheduled tasks and automated workflows, WorkBuddy can silently handle repetitive work in the background. Examples given officially include—automatically generating a work daily report at 9:00 every day, automatically running tests after code commits, aggregating data and generating a report weekly, periodically checking code standards, and periodically fetching and organizing industry news.

Which work suits automation? The official criteria: tasks that arehighly repetitive, rule-based, and require no real-time human intervention.

• For configuring remote channels (WeChat assistant, WeCom, and others—6 in total), see 5.1 Assistant Overview: Six Remote Channels and Security Boundaries
• For the full configuration of scheduled tasks, see 3.3 Scheduled Tasks: Letting WorkBuddy Work on Its Own on Time; for a hands-on weekly report example, see A1 Automated Weekly Report: Every Friday at 17:00, It Aggregates and Delivers Automatically

You should see: repetitive work no longer needs manual triggering every time; before letting go remotely, you've already watched it run the full flow on your own machine.

• I can name the three traits that suit automation: highly repetitive, rule-based, and requiring no real-time human intervention

Step 8: Outsource repetitive labor with "laziness + motivation"

Why: The official "laziness" doesn't mean slacking off—it means handing mechanical, repetitive work to AI as much as possible: formatting code, writing templates, organizing data—these standardized actions are its job in the first place. And the essence of "motivation" is giving the AI a stronger role setting and quality expectations: it has no emotions, but this kind of phrasing influences its word choice, depth of analysis, and output structure.

How to do it: a pair of contrasting examples from the official docs:

Lazy version (outsourcing mechanical labor):
Help me reformat the phone numbers in the 2000 rows of this Excel into the xxx-xxxx-xxxx format;
if an area code already starts with 0, keep it; otherwise, prepend the default area code 0755 to all of them.

Motivated version (using a role and quality standards to improve results):
You are a financial analyst who has worked in investment banking for 10 years. Using the finest research report you've ever seen as the standard,
help me analyze this company's financial statements. Focus on:
1) whether the revenue structure is healthy;
2) whether there are hidden risks in cash flow;
3) competitive advantages compared to peers.
Give a clear investment recommendation; if the data is insufficient, you may make bold assumptions, but label the assumptions.
What I want is insightful analysis, not data shuffling.

The underlying logic (official wording): Your energy should go first to decision-making and creative thinking, while mechanical execution should be handed to AI as much as possible—let the right people and the right tools do what they're best suited for.

You should see: mechanical labor disappears from your to-do list; for important analyses, what you get is not data shuffling but conclusions with viewpoints and labeled assumptions.

• I have handed at least one mechanical, repetitive task to WorkBuddy, and given important analyses a clear role and quality standards

For details, you can cross-reference the official documentation: WorkBuddy 10 Getting-Started Tips.

Checkpoint ✅

• I can recite the three-element formula (do what + with what + how), and on the spot turn a vague requirement into a clear prompt with a path and an output format
• I have broken a large task into at least two rounds of progress, confirming the direction before continuing in each round
• I have used at least one adjustment method on an unsatisfactory result (pointing out problems / restating / adding constraints / switching perspective), rather than settling everything in one round
• I have a backup habit before touching real files, and I know "Roll back" reverts the conversation and outputs together
• Be able to name the characteristics of tasks suitable for automation: highly repetitive, with clear rules, and requiring no real-time human intervention

Pitfall reminders

❌ Sending out vague requirements as-is

Symptom: casually tossing out a line like "help me tidy up the meeting minutes from last time," then being deeply disappointed by the result.

Cause: WorkBuddy cannot read minds. The less information you give, the more chaotic its room for interpretation becomes—it doesn't know where the file is, which fields are needed, or what format to use.

Correct approach: complete it with the three-element formula—what to do, what you have (file paths), and how (output format and constraints). If you have no clue at all, ask it first: "I want to do XX; what information do you need from me?"

❌ Dumping a big task all at once and giving up after an unsatisfactory first round

Symptom: sending "translate and summarize this entire 50-page report" in one go, getting a huge output with nothing usable; concluding "this tool doesn't work" upon receiving an unsatisfactory first version.

Cause: throwing a huge requirement over at once easily leads to loss of control; and the essence of AI conversation is precisely multi-round refinement—the first answer is only a starting point.

Correct approach: break large tasks into rounds and confirm the direction each round; if unsatisfied, keep narrowing things down with the four adjustment methods—point out the problem directly, rephrase from a different angle, add constraints, or switch role perspectives.

❌ Letting it modify important files without a backup

Symptom: only after the edits do you discover that a paragraph you wanted to keep was deleted and the formatting was messed up, with the original version already overwritten—leaving you no choice but to redo it.

Cause: WorkBuddy sometimes "over-edits"—however capable it is, it isn't absolutely stable every time, and you may not be able to stop it in time mid-execution.

Correct approach: make a copy before editing (append "_backup" or a date to the file name); for batch changes, review the preview comparison table before confirming execution; after an error, use the conversation "rewind" to roll back the conversation and its outputs together. See the three-layer safety net in step 6 of this lesson.

❌ Going remote right after getting started, or grinding away in a ruined context

Symptom: right after installation, setting up remote commands via WeChat, then it performs operations beyond expectations where you can't see them, with no time to stop it; or a session that has become "forgetting what was said earlier" yet you keep struggling to patch it up.

Cause: remote means autonomous action, with zero visibility into the process for you; when a session gets too long, the contexts contaminate each other and drift further off course.

Correct approach: first use it on the desktop while watching, get familiar with how it executes and its risk boundaries, then gradually let go with remote control (see step 7); if the context is ruined, start a new task and concisely restate the key background.

Advanced tips (optional)

🔧 Start with the official prompt templates. The task creation page offers a set of prompt templates organized by scenario (daily office work, code development, design and creativity); hovering the mouse previews the gray text in the input box, and you click to actually fill it in only after confirming it fits—ideal for the transition period when the three-element formula still doesn't flow smoothly. See 2.3 Input Methods Explained: Voice, Files, and Prompt Templates.

🔧 When the requirement isn't thought through yet, start with Plan mode first. For multi-step tasks with undetermined premises, rather than forcing out a prompt and gambling on the direction, have it propose a plan first and execute only after you confirm—in official terms, "correct the direction within tens of seconds, instead of discovering the approach was wrong only after the results finish running." See 2.4 Three Execution Modes.

🔧 Turn well-polished prompts into scheduled tasks. Once a prompt has been refined over several rounds and is stable and usable, don't let it live only in the conversation history—add a schedule rule and it can run automatically every week; for a full walkthrough see A1 Weekly Report Auto-Generation: Automatically Aggregate and Hand It Off Every Friday at 17:00.

Lesson summary

✅ Three-element formula: what to do + what you have + how—a qualified WorkBuddy prompt states at least these three things clearly; don't make the AI guess your intent.

✅ Pacing: break large tasks into rounds, accomplish one thing at a time, confirm the direction first each round; if unsatisfied, refine over multiple rounds (point out problems / rephrase / add constraints / switch perspective)—don't decide life or death in one round.

✅ Three moves for quality: give an identity (expert role), give examples ("follow this"), use multiple sessions (decisively start fresh when the context is ruined).

✅ Safety boundaries: back up files before touching them, check previews first, learn to use rewind; practice locally first, then let go with remote.

✅ Letting go: hand highly repetitive, clearly ruled tasks that need no real-time human intervention to scheduled tasks; outsource mechanical labor (be lazy), and give roles and quality standards to important analyses (motivate).

10 tips at a glance:

Tip	Key action
1 Express clearly	What to do + what you have + how, with paths and output format
2 Small quick steps	Break big tasks into rounds, confirm direction each round
3 Multi-round adjustment	Point out problems / rephrase / add constraints / switch perspective
4 Local first, then remote	Practice on desktop before letting go
5 Give an identity	Pick the right expert role
6 Give examples	"Follow this"
7 Multiple sessions	Different tasks in different windows; start a new task when the context is ruined
8 Backup and version management	Copy before editing; know how to use rewind
9 Automation	Let scheduled tasks run repetitive work
10 Laziness + motivation	Outsource mechanical labor, raise quality expectations

Next lesson preview

In step 4, "give an identity" only touched on the essentials; the next lesson expands on it in depth. In the next lesson you'll learn 3.2 Experts and Expert Teams: Giving WorkBuddy a Professional Identity.

You will learn:

• What an expert's persona, methodology, and toolchain are all about
• How expert teams are automatically decomposed and assigned tasks by the team lead
• How to choose among Skill, expert, and expert team
• Where to find experts: search and sharing

Related tutorials

• Conversation Advanced: Multi-Round Adjustment, Rewind, and References
• Three Execution Modes: Default (Agent), Plan, and Ask-Only
• Weekly Report Auto-Generation: Automatically Aggregate and Hand It Off Every Friday at 17:00