How to Describe Automation Tasks in Plain English

When you use an AI browser automation platform like Autonoly, the task description you write is not just a request — it is the entire instruction set. There is no drag-and-drop flowchart. No CSS selectors. No code. Your words are the code. If the model is new to you, our explainer on what automation is and our AI automation guide show why plain-English instructions work.

This is both the greatest strength and the most underestimated challenge of natural language automation. The AI agent genuinely understands English. It can read a web page, figure out which button to click, fill in a form, extract data from a table, and navigate multi-step workflows. But the quality of its output is directly proportional to the quality of your input.

This matters more than most people realize. In our experience across thousands of automation tasks, the difference between a vague description and a well-structured one is not a marginal improvement — it is the difference between an automation that works on the first attempt and one that requires three or four rounds of correction. A few extra minutes spent on your task description saves hours of back-and-forth.

This guide teaches you a practical framework for writing task descriptions that produce excellent results. You will learn what to include, what to avoid, and how to handle the edge cases that trip up most users. Whether you are automating web scraping, form filling, document downloads, or data transfers between apps, the principles are the same.

What Happens Inside the AI Agent

Understanding how an AI agent processes your instructions helps you write better ones. When you submit a task description to Autonoly's AI agent chat, here is what happens:

1. Parsing: The agent reads your description and identifies the goal, the target website, the specific actions, and the desired output.
2. Planning: It creates a mental plan for how to accomplish the task — which pages to visit, what to look for, which interactions to perform.
3. Execution: It opens a real cloud browser (which you can watch in real time) and starts navigating, reading the page, and acting.
4. Adaptation: As it encounters the actual page content — pop-ups, cookie banners, login screens, unexpected layouts — it adjusts its plan.
5. Output: It delivers the results in the format you specified, or asks for clarification if it gets stuck.

The key insight: steps 2 through 4 all depend on step 1. If your description is ambiguous, the agent's plan will be ambiguous. If it is precise, the plan will be precise. You are the architect — the agent is the builder.

After analyzing thousands of successful automation tasks, we have identified four components that consistently produce the best results. We call it the WHAT-WHERE-HOW-OUTPUT framework.

Component 1: WHAT — The Core Action

Start with a clear verb that describes what should happen. This is the single most important sentence in your entire description. It anchors the agent's understanding of the goal.

Strong action verbs for automation:

• Extract — Pull specific data from a page (names, prices, emails, phone numbers)
• Fill — Enter data into form fields
• Download — Save files (PDFs, CSVs, images) from a website
• Search — Find specific items, profiles, or listings
• Monitor — Check a page for changes
• Transfer — Move data from one system to another
• Submit — Complete and submit a form or application
• Compare — Gather information from multiple sources for comparison

Notice that each verb implies a specific type of outcome. "Extract" means data coming out. "Fill" means data going in. "Download" means files saved. This clarity helps the agent plan its approach from the start.

Component 2: WHERE — The Target Location

Specify exactly where the action should take place. The more precise, the better.

Best practices for the WHERE component:

• Include the full URL when possible: "Go to amazon.com/best-sellers/electronics" is better than "Go to Amazon's electronics section."
• Name the specific page or section: "On the Pricing page" or "In the Sales Dashboard tab."
• For login-required sites: Mention that login is required and provide credentials or indicate where the agent can find them.
• For multi-page workflows: Describe the starting point clearly. The agent will navigate from there.

Component 3: HOW — The Specific Steps and Context

This is where most users either under-specify or over-specify. The right level of detail is: enough that a reasonably intelligent person could follow your instructions on their first attempt, but not so much that you are writing pseudo-code.

Include in the HOW component:

• Login credentials if the site requires authentication
• Navigation instructions for complex sites: "Click on Reports, then Monthly Summary"
• Filter or search criteria: "Filter by date range: last 30 days" or "Search for 'wireless headphones under $50'"
• Pagination handling: "Go through all pages of results" or "Only the first 3 pages"
• Specific field values for form filling: "Set Company Name to 'Acme Corp', EIN to '12-3456789'"
• Conditional instructions: "If the page asks for a verification code, enter 123456"

Component 4: OUTPUT — The Deliverable

Tell the agent exactly what you want to get back and where to put it. This is the component users most frequently forget, leading to results that are technically correct but not in the format they needed.

Specify these output details:

• Format: "Save as a CSV file" or "Create a Google Sheet" or "Send results as a Slack message"
• Structure: "Create columns for Name, Email, Phone, Company" or "One row per product"
• Destination: "Save to my Google Drive" or "Send to [email protected]" or "Add to the existing sheet called 'Q3 Leads'"
• Naming: "Name the file 'competitor-prices-{date}'" if file naming matters

The OUTPUT component connects naturally to Autonoly's integrations — Google Sheets, Slack, email, and more. Mentioning the destination in your description lets the agent deliver results exactly where you need them.

Theory is useful, but examples are better. Here are ten real task descriptions, each shown in both a weak and strong version, with an explanation of what changed and why it matters.

Example 1: Web Scraping — Product Research

What changed: The strong version specifies the search query, the exact data fields, the scope (3 pages), and the output format. The weak version forces the agent to guess on every single one of those dimensions.

Example 2: Form Filling — Government Portal

What changed: The strong version provides the exact URL, login method, the specific form to find, every field value, and post-submission instructions. The weak version does not even identify which government website to use.

Example 3: Data Extraction — Competitor Monitoring

What changed: The strong version names the exact competitor URLs, specifies the data fields (monthly vs. annual pricing), and defines a structured multi-tab output. The weak version does not even name the competitors.

Example 4: Document Downloads — Invoice Collection

What changed: The strong version specifies the vendor portal, credentials, date range, pagination handling, and exact storage destination. Note the use of "this year" instead of a hardcoded year — this makes the task description reusable across time periods.

Example 5: Lead Generation — LinkedIn Research

What changed: The strong version defines the job titles to search for, the geographic filter, the exact data fields, a filtering criterion, a result limit (50), and the output destination.

Example 6: Report Generation — Pulling Analytics

What changed: The strong version provides the exact navigation path within Google Analytics (which has a complex, deeply nested interface), specifies which reports and metrics to export, and defines the delivery method.

Example 7: Price Monitoring — Recurring Task

What changed: The strong version provides the exact URLs, the data points to capture, and crucially, tells the agent to append to an existing spreadsheet with the date — making this a description that can be scheduled to run daily and build a historical price dataset over time.

Example 8: Multi-Site Workflow — Insurance Quotes

What changed: The strong version provides all the vehicle details the forms will ask for, the specific carrier portals with login credentials, and a structured output format for comparison. The weak version gives the agent no vehicle information, no carrier names, and no login details.

Example 9: Data Entry — Spreadsheet to Web Form

What changed: The strong version maps spreadsheet columns to form fields, provides the exact URL, includes error handling instructions, and defines a tracking mechanism (marking column G) so you know which entries succeeded.

Example 10: Research — Gathering Specific Information

What changed: The strong version defines exactly what "research" means — four specific data points per company — and tells the agent where to find each piece of information (company website vs. LinkedIn). The weak version is completely open-ended.

Even with a good framework, certain patterns consistently lead to suboptimal results. Here are the seven most common mistakes we see, with concrete fixes for each.

Mistake 1: Being Too Vague

The problem: Descriptions like "automate my work" or "do something useful with that data" give the agent nothing actionable. It is the equivalent of telling a taxi driver "take me somewhere nice" — they might pick a great restaurant, or they might drive in circles.

The fix: Start with the WHAT-WHERE-HOW-OUTPUT framework. Even a rough description using all four components outperforms a polished but vague one. If you cannot fill in all four components, you may not have a clear enough picture of the task yourself — which is worth resolving before involving automation.

Mistake 2: Writing Pseudo-Code

The problem: Some technical users default to writing instructions like code: "FOR EACH row IN spreadsheet DO: navigate(url); fillField(#name-input, row.name); click(#submit-btn); ENDFOR". This is counterproductive. The AI agent does not execute CSS selectors or programmatic commands — it reads pages visually and semantically, just like a human.

The fix: Write in plain English. "For each row in my spreadsheet, go to the website, fill in the name field with the value from that row, and click Submit" achieves the same result without brittle selectors. The agent will find the right form field by understanding the page layout, not by matching a CSS selector that might change tomorrow.

Mistake 3: Omitting Login Credentials

The problem: "Go to my CRM and export the leads." The agent navigates to the CRM, hits a login page, and has no idea what credentials to use. Now it is stuck.

The fix: Always mention how to log in. You can provide credentials directly ("Log in with [email protected], password: ****"), reference your credential vault ("Use the stored credentials for Salesforce"), or specify that no login is needed ("This page is publicly accessible — no login required"). If the site uses multi-factor authentication, mention that too and describe how to handle it.

Mistake 4: Forgetting Pagination

The problem: "Extract all job listings from Indeed for 'data analyst' in New York." The agent extracts the first page (typically 15-20 results) and stops. There are 500+ results across 25+ pages, but the description did not mention pagination.

The fix: Explicitly state your pagination expectations: "Go through all pages of results" or "Extract results from the first 5 pages" or "Continue until you have at least 200 results." Setting a boundary also prevents the agent from spending excessive time on a task with thousands of pages of results.

Mistake 5: Assuming Context the Agent Does Not Have

The problem: "Fill in the usual fields on the vendor form." You know what the "usual fields" are because you fill out this form every week. The agent has never seen it before.

The fix: Spell out every field value explicitly the first time. Once the agent has completed the task successfully, you can save the description as a template for future runs. Think of the first run as training — be exhaustively specific. Subsequent runs can reference "the same values as before" if you are using the visual workflow builder to create a reusable workflow.

Mistake 6: No Output Specification

The problem: "Get the competitor pricing information." The agent extracts the data — but then what? Should it display it in the chat? Save to a spreadsheet? Send an email? Without output instructions, the agent defaults to showing results in the conversation, which may not be what you wanted.

The fix: Always end your description with explicit output instructions. "Save to a new Google Sheet called 'Competitor Pricing'." "Send the data to #marketing-updates in Slack." "Download as a CSV file." Autonoly integrates with Google Sheets, Slack, email, and more, so specifying the destination is always worth doing.

Mistake 7: Not Handling Edge Cases

The problem: Your description works perfectly for the happy path, but the first time the site shows a pop-up, a CAPTCHA, or an unexpected error, the agent gets stuck.

The fix: Add conditional instructions for foreseeable problems. You do not need to anticipate every possible issue — just the common ones. See the next section for a comprehensive list of edge case handling patterns.

Real websites are messy. Pop-ups appear, pages load slowly, layouts change between visits, and forms have validation rules that are not obvious until you trigger them. The best task descriptions anticipate these situations with conditional instructions.

Here is a library of edge case patterns you can copy and adapt for your own task descriptions.

Pop-ups and Overlays

Nearly every commercial website displays pop-ups — cookie consent banners, newsletter sign-up modals, chat widgets, promotional overlays. These can block the agent from interacting with the underlying page.

Login Failures and Session Timeouts

Login-required sites can fail for various reasons: wrong credentials, expired sessions, MFA challenges, or temporary lockouts.

Pagination and Infinite Scroll

Data extraction tasks often involve multiple pages of results, and the pagination mechanism varies between sites.

Missing or Inconsistent Data

When extracting data from multiple listings, some entries may be missing fields that others have.

Rate Limiting and Slow Pages

Some websites load slowly or throttle requests when they detect rapid automated access.

Large Result Sets

Sometimes you discover the task is much larger than expected — a search returns 10,000 results instead of 100.

Form Validation Errors

Web forms often have validation rules that reject certain inputs — date formats, phone number formats, required fields that are not obvious.

Dynamic Content and Loading States

Modern web applications load content dynamically — data tables that take a few seconds to populate, dropdown menus that load options from an API, and dashboards that render charts after the page frame loads.

You do not need to include all of these patterns in every task description. Pick the ones relevant to your specific task. Over time, as you refine your descriptions through the iteration cycle, you will naturally add the edge case handling that matters for your particular websites and workflows.

Copy, customize, and use these templates as starting points for common automation categories. Replace the bracketed placeholders with your specific details.

Template 1: Web Scraping / Data Extraction

Template 2: Form Filling (Single Form)

Template 3: Batch Form Filling (From Spreadsheet)

Template 4: Document Download

Template 5: Multi-Site Comparison

Template 6: Monitoring and Alerting

These templates serve as solid starting points, but the best task descriptions are the ones you refine through iteration. Start with a template, run it, review the results, and adjust. Within 2-3 iterations, you will have a description perfectly tailored to your specific website and workflow.

Your first task description does not need to be perfect. In fact, trying to write the perfect description on the first attempt usually wastes more time than just starting with a good-enough version and refining it based on real results.

Step 1: Describe (First Draft)

Write your initial task description using the WHAT-WHERE-HOW-OUTPUT framework. Cover the basics: what action, which website, general instructions, and where to save results. Do not agonize over edge cases yet — you will discover them.

Time investment: 2-5 minutes.

Step 2: Run

Submit the description to the AI agent and watch it execute through the live browser view. Watching the agent work is the fastest way to spot gaps in your description. You will see moments where it hesitates, takes a wrong turn, or misses something — those are the areas to refine.

Time investment: depends on task complexity, but you are observing, not working.

Step 3: Review

Examine the results critically. Ask yourself:

• Did it go to the right website and the right page?
• Did it extract or enter all the data fields I needed?
• Is the data accurate and complete?
• Did it handle pagination correctly?
• Is the output in the format and location I specified?
• Were there any errors or unexpected behaviors?

Common findings after the first run:

• Missed a data field you assumed was obvious
• Stopped at the first page when you wanted all pages
• Got blocked by a pop-up or login screen you forgot to mention
• Saved data in the wrong format or location
• Extracted data from the wrong section of the page

Step 4: Refine

Update your task description to address exactly the issues you found. Be specific: if the agent missed the "phone number" field, add "phone number" to your list of fields. If it stopped at one page, add "go through all pages of results." If a pop-up blocked it, add "if a pop-up appears, close it."

Step 5: Repeat

Run the refined description and review again. Most tasks are perfected in 2-3 iterations. Some complex multi-step workflows may take 4-5 iterations, but each cycle is fast — minutes, not hours.

Once you have a task description that produces consistent, accurate results, you have something truly valuable: a reusable automation recipe. Save it. You can run it again whenever you need to, schedule it for recurring execution, or use it as the foundation for a visual workflow that chains multiple tasks together.

Real Iteration Example: Competitor Price Monitoring

Here is how a real user refined their task description over three iterations:

Iteration 1: "Get competitor prices from their website."

Result: The agent asked which competitor. No website was specified.

Iteration 2: "Go to competitor.com/pricing and extract all plan names and their prices."

Result: Got plan names and monthly prices, but missed annual pricing and the feature lists that differentiate plans.

Iteration 3: "Go to competitor.com/pricing. For each plan listed on the page, extract: plan name, monthly price, annual price (if available — some plans only have monthly), and the complete list of features included. If features are hidden behind a 'See all features' or 'Compare plans' link, click it to expand. Save everything to a Google Sheet called 'Competitor Pricing Tracker' with columns: Plan Name, Monthly Price, Annual Price, Features."

Result: Complete, accurate data with all pricing tiers and features captured. This description now runs weekly on a schedule.

Total time to reach perfection: roughly 15 minutes across three runs. Time saved per week going forward: 45 minutes of manual research. That is a payback period measured in days.

Once you have mastered the basics, these advanced strategies help you tackle more complex automation scenarios.

Strategy 1: Break Large Tasks into Smaller Steps

If your task involves five different websites, three different types of data processing, and output to multiple destinations, consider breaking it into smaller, focused tasks rather than writing one massive description.

Breaking tasks apart has three benefits: each individual task is simpler and more likely to succeed on the first run, you can debug each step independently, and you can reuse individual tasks in different combinations.

Strategy 2: Use Reference Points Instead of Absolute Positions

Web pages change. Elements move. New sections get added. Instead of describing locations by position ("the third button from the left"), use semantic references that are resilient to layout changes.

Strategy 3: Provide Examples of Expected Output

When the output format matters, show the agent what you expect rather than just describing it.

Showing a concrete example row eliminates ambiguity about formatting, column order, and data granularity (one row per company vs. one row per contact).

Strategy 4: Define Success Criteria

For tasks where accuracy matters more than speed, include a definition of what a successful outcome looks like.

Strategy 5: Include Screenshots or Annotated References

For complex websites with unusual layouts, you can reference specific visual elements in your description. If you have previously visited the site, describe what you see in a way the agent can match:

"The data I need is in the section with the blue header that says 'Account Summary'. It is below the navigation bar and above the 'Recent Transactions' section. The table in this section has columns for Date, Description, Amount, and Balance."

This kind of spatial and visual reference helps the agent identify the right elements on complex dashboards and portals where multiple data tables or sections compete for attention.

Strategy 6: Make Descriptions Time-Independent

If you plan to schedule a task for recurring execution, write the description so it works without modification every time it runs.

Relative dates and time references ensure your automation runs correctly whether it executes tomorrow or six months from now. This is especially important when you use scheduled workflows that run automatically on a recurring basis.

You now have a complete toolkit for writing task descriptions that produce excellent automation results. Here is how to put it into practice immediately.

Your First Five Minutes

1. Pick one task you currently do manually that is repetitive and web-based. Start with something straightforward — data extraction from a single site or a simple form filling task.
2. Write a description using the WHAT-WHERE-HOW-OUTPUT framework. It does not need to be perfect. Cover the basics: what action, which URL, any login details, and where to save the results.
3. Run it on Autonoly's AI agent chat and watch through the live browser view.
4. Refine based on what you observe. Add missing details, fix any incorrect assumptions, handle edge cases you noticed.
5. Save the perfected description for future use.

The Cheat Sheet

Keep these principles visible when writing task descriptions:

The Scaling Path

Once you are comfortable with single-task descriptions, you can build on this foundation:

• Chain tasks into workflows using the visual workflow builder. One task's output becomes the next task's input.
• Schedule recurring tasks — your perfected descriptions run automatically daily, weekly, or monthly.
• Connect outputs to other tools via integrations — pipe data directly into Google Sheets, send alerts via Slack, or email reports to stakeholders.
• Build a library of task templates your entire team can use. The best descriptions become reusable automation recipes that anyone can run.

Ready to try it? Create your free Autonoly account and describe your first automation task. You might be surprised how close the first result gets — and how quickly the second iteration nails it.