How to Teach an AI Agent What to Look For (Without Prompting)

There’s a common assumption about building AI agents.

Most people think you start with prompting — you sit down, you write out what you want the agent to do, and then you connect it to your tools. The workflow comes first. The instructions come first.

That’s backwards.

The real first step is teaching the agent what to look for. And the fastest way to do that isn’t writing — it’s showing.

The Payment Reminder Problem

I was working with Amanda, a CPA firm owner, on automating her calendar. She was getting automated payment reminder emails from Payoneer — notifications that a vendor auto-draft was coming through. She wanted those to automatically create calendar events so she’d see upcoming charges without having to dig through her inbox.

Classic agent scenario: an incoming email triggers an action.

Before I wrote a single line of workflow logic, I asked her to do one thing.

“Can you take a screenshot of that email? Your whole screen — including Outlook and everything.”

She thought it was a strange request. But here’s why it matters.

The Recognition Problem

An agent can’t identify an email type from a description alone.

You can write in a prompt: “When you receive a payment reminder email from Payoneer, add it to the calendar.” But the agent doesn’t know what that actually looks like in practice. What’s the sender address format? What does the subject line pattern look like? How is the body of the email structured? Is there a specific dollar amount field, or a specific phrase that signals this type of notification versus any other automated email?

When you give the agent a screenshot — a real example of the exact thing you want it to act on — it has something concrete to recognize. You’re not describing the trigger in words and hoping the agent interprets them correctly. You’re saying: this. When you see something like this.

The screenshot becomes the training data. Not in the deep-learning, model-training sense. In the “here’s exactly what you’re looking for in the wild” sense.

Showing Beats Describing

This principle applies beyond screenshots.

Whenever you’re building an agent that needs to recognize or categorize something, the fastest path to getting it right is giving it an example of the real thing, not a description of it.

Building an agent that categorizes expenses? Give it five real receipts, not a definition of each expense category.

Building an agent that routes support tickets? Give it sample tickets for each category, not a list of keywords.

Building an agent that drafts follow-up emails? Give it two or three examples of how you actually write follow-ups, not a list of style guidelines.

The agent can pattern-match from concrete examples far more reliably than it can interpret abstract descriptions. This is one of the most practical things I’ve learned from building client automations.

Where the Real Work Is

Here’s what surprises most people when they start building agents: the workflow logic — the “if this, then that” — is usually the easy part.

The hard part is the trigger. Figuring out exactly how the agent identifies the moment when it should do something. And then making sure that trigger is reliable enough that the agent fires when it should and doesn’t fire when it shouldn’t.

Once I had the screenshot of Amanda’s Payoneer email, the actual Lindy build took about 15 minutes. The recognition step — identifying the trigger pattern clearly enough that the agent could be trusted to catch it reliably — was where the real work happened.

This is almost always the case. When a client says “the agent isn’t working,” the problem is usually upstream of the workflow. It’s not recognizing the trigger correctly.

A Simple Starting Point

If you’re building your first agent and you’re not sure where to begin, start with documentation rather than prompting.

Before you open your automation tool:

1. Find a real example of the thing you want the agent to act on (an email, a message, a form submission, a data entry)
2. Take a screenshot or save the actual example
3. Write down what you want the agent to do when it sees this thing
4. Then build the workflow from that documented example

This approach gives the agent something specific to work with and gives you something concrete to test against.

You don’t need coding experience to build useful agents. But you do need to be able to clearly document what you’re trying to automate. The screenshot is often the best place to start.