If You Keep Repeating the Prompt, Build the Agent

If you keep giving an AI tool the same instructions, congratulations: you may not be “getting better at prompting.” You may be stuck doing unpaid setup work for a very forgetful intern.

You remind it what kind of answer you want. You restate the project rules. You tell it which sources count and which ones are stale. You explain the tone again. You ask it to check the same failure modes again. Then, a week later, you open a new chat and perform the ritual from the top.

That repeated steering is a signal. If every draft starts with the same voice rules, every research pass starts with the same source warning, or every code review starts with the same “please check the tests before getting poetic” note, the pattern is waving a little flag.

It usually means there is a small custom agent waiting to exist.

A useful custom agent is not a magic worker, and it is not a saved prompt wearing a fake mustache. The point is to save the judgment you keep having to reload: the standards, boundaries, checks, and next-step habits that make your work better when you remember to apply them.

Generic chat answers once. A good agent remembers the job.

Generic AI is strongest when the question is broad, the stakes are low, and the context can fit in the current conversation. It can brainstorm, explain, summarize, translate, and help you get unstuck.

But recurring work is where generic chat starts leaking time. You do not only need an answer. You need the answer shaped by rules that are easy to forget under pressure. Otherwise, the quality of the work depends on whether Past You remembered to brief the machine before Present You ran out of patience.

For example:

• A writing helper should know the reader, the promise, the voice, and the kind of vague phrasing you want cut.
• A code reviewer should know the project conventions, test expectations, security concerns, and what kind of change is too broad.
• A research helper should know which sources count, what kind of claim needs evidence, and when to say “I do not know” instead of filling the gap.
• A personal operations helper should know your preferred output shape, your decision boundaries, and what not to turn into a side quest.

You can type all of that every time. Or you can turn the repeatable part into an agent.

What belongs in a custom agent

The best agent instructions are not vibes. They are working rules.

Good ingredients include:

1. The job: what this agent is responsible for, and what it is not responsible for.
2. The audience: who the output is for, and what situation they are in.
3. Source boundaries: which files, docs, repositories, tools, or references are allowed.
4. Quality bars: what “good” means before the answer is treated as done.
5. Output shape: the format that makes the result easiest to use.
6. Stop conditions: when the agent should ask, block, or refuse to invent.
7. Known mistakes: the failure modes it should check before handing work back.

That last one matters. A custom agent gets more useful when it captures corrections. If you keep saying “do not do that again,” the fix should not live only in your patience. It should become part of the instructions the agent actually works from.

When an agent is worth making

Create a custom agent when the work is recurring and the repeated setup is meaningful.

A good test is simple: have you explained the same standard three times?

If you have explained the same standard three times, do not start by writing a better prompt. Decide whether that standard belongs in an agent, a skill, a workflow, a template, or a script.

If yes, the standard probably belongs somewhere durable. Sometimes the answer is a checklist. Sometimes it is a template. Sometimes it is a script. Use an agent when the repeatable part still needs judgment, not just button-pushing.

Custom agents are especially strong for review loops:

• “Check this draft against our voice and quality bar.”
• “Review this code using the project testing rules.”
• “Turn this messy idea into a card, but do not start drafting yet.”
• “Search these sources and separate evidence from speculation.”
• “Close out this task and capture only the follow-ups that matter.”

Those jobs are not just tasks. They are the same little judgment calls, over and over.

When not to make one

Do not build an agent for every stray thought that wanders across the keyboard.

If the task is one-off, use normal chat. If the answer is purely mechanical, a script may be better. If the rules are still changing every hour, wait until the pattern stabilizes. Otherwise, the agent may preserve the mess in amber.

If you cannot describe what good output looks like, the agent will probably preserve confusion instead of solving it. It will just do it confidently, which is worse because now the confusion has a badge.

Also be careful with secrets and authority. A custom agent should not become a drawer full of private details it does not need. Give it the smallest context that helps it do the job well. Give it clear limits. Make the stop conditions obvious.

The goal is not to automate your judgment away. The goal is to stop losing it between sessions.

Start small

Pick one repeated friction.

Not a whole life system. Not a giant company workflow. One place where you keep re-explaining yourself.

Write down:

• What job should this agent do?
• What should it read first?
• What should it never touch?
• What mistakes should it catch?
• What should the final answer look like?
• How will you know whether it helped?

For example: “Before I publish a draft, check whether the opening has a real reader, whether the examples are concrete, and whether any paragraph sounds like a committee found a keyboard. Then give me the smallest useful fix.”

That is small enough to test and useful enough to keep.

Then test it on real work. The first version will miss things. That is fine. The misses are the material. Every correction tells you whether to update the agent, simplify the job, split it into a smaller helper, or replace it with a checklist.

A good custom agent is not finished because it sounds clever. It is useful because it reduces repeated steering, catches predictable mistakes, and helps your own standards show up earlier.

That is the real reason to create your own agents: not to make the machine look impressive, but to make your best judgment easier to summon when the blank chat window is staring back like it has never met you before.