You've already taught AI how to do this job.
But you’re still manually feeding it the input you need to process every time.
How about we take that off your plate too?
Say your job is writing follow-up notes after client calls, and you drop the call transcripts into a folder.
Right now, running the job means dragging that file into Codex yourself.
Once you build a route, you just type one line, the AI looks through that folder, grabs the file, does the job, and sends you a link to the result when it's ready to review.
That's what a route gives you:
A place for new information (which the AI will automatically look at)
A place for the finished result to wait for your review
In this last part of the guide, you'll build that route around the Skill you saved in Part 3.
By the end, you’ll have a tested route for the job.
You can just name the next case, start the run, and know where to find the result when it’s ready.
Step 1. Try the Skill on a different case
You’ve run the job once.
But how confident are you that it can handle different cases in the future?
Only one way to find out. Let’s test it out with a second case.
Open a fresh chat under the same project.
Pick a second case that's really different.
For a client recap, use another call with different people and different decisions.
For a feedback report, use another period with different comments.
Attach the new input, paste in the relevant text, or point the AI to the exact file in the project.
If you’re not sure what to hand over, check the "I will use" line on your job card. If the job needs multiple files, bring all of them.
Now, use the starting request saved in your job card.
Don't repeat the preferences and corrections you already locked in during the previous Part.
This is your chance to see if AI remembers them without being told twice.
Open the full result and check it against the new source and your job card:
Does it include everything this job is supposed to produce?
Do the names, dates, and facts actually belong to this case (and not the first one)?
Did AI apply the reusable corrections you confirmed in Part 3?
Did it run the saved checks and flag anything it wasn't sure about?
If something's off, call it out the same way you did in Part 3.
Answer whatever's in "What you decide," and keep revising until you're happy with the result.
Tell the AI when you accept it, and have it save that version.
Step 2. Check & customize the route
You’ve now run this job twice.
The Skill knows what to do, but you’re still handling some of the boring parts around it.
You have to supply the input yourself.
Finished work can stay buried in Codex unless you move it somewhere else.
A route takes care of that setup.
It tells the AI where to find the case you name, where to put finished work, and what to do when something goes wrong.
You still start the job yourself and review the result before anything else happens.
For now, keep the route inside the project.
You’ll use fixed folders for the input, finished work, and run records.
If you later want the job to read from or write to another app, check Optional Help at the end.
Check the route you currently have
Before changing anything, ask AI to show you how the job works right now.
Say:
Show me the route this job follows right now: what starts a run, where the input comes from, which Skill runs, where the result goes, how I review it, what happens if I run the same input twice, and what happens if something required is missing. Just describe it as it stands. Do not change, save, or activate anything.
The AI should come back with something like this:
Do a quick check that the AI is using the saved Skill you tested in Step 1.
But take a closer look at where it expects the input to come from and where it currently saves the finished result.
You’ll probably see that some parts of the route still depends on you doing things by hand.
That’s what you’ll fix next.
Customize the route
Give this job three fixed folders inside the project:
Input for new source files
Runs for a record of every attempt
Review for successful finished results
Send this:
Update the route for this job to use three fixed project folders: Input, Runs, and Review.
When I name an input, get that exact file or file set from Input and leave the source unchanged. Run the saved Skill for this job.
If the job finishes successfully, save every required result in Review and create a dated run receipt in Runs that identifies the input, results, and checks.
If that exact input has already completed this route, stop and point me to the earlier result instead of creating another one.
If the job cannot finish because information is missing, a check fails, or something else blocks the run, keep unfinished work out of Review. Explain what stopped the job and what I need to fix. Record the failed attempt in Runs.
Keep the route manual. Do not connect an app, create a schedule, run the job, or change anything outside this project.
Show me the complete updated route before I activate or test it.
The AI should come back with an updated route:
You should be able to tell where the next input goes, what starts the job, where a successful result will end up, and where to look if a run stops.
Check your AI Brain Starter folder too, for the newly created folders.
Step 3. Run the same job with the new route
You already know what a good result looks like here (since you already approved it on Step 1).
Now check whether the AI brain can do it again using the route you just built.
Use that same case.
Ask AI to copy the input into the agreed source folder, keeping the original untouched, and show you the exact input and result paths it'll use.
Place a copy of [specific input] into the Input folder while preserving the original. Show me the exact input path and planned result paths.
The AI should confirm that it did.
Make sure the new result gets its own spot and doesn't overwrite your accepted comparison copy.
Once everything is in order, fill in the brackets and send:
I approve this saved route card for one test on [exact input file or file set]. Prepare the agreed setup and run the complete job inside this project. Leave sources and earlier accepted results unchanged. Save every required result for review and the dated run receipt, with links I can open. Stop and explain if you can't finish. Do not connect an app, create a schedule, send, publish, purchase, delete, or change anything outside this project.
The AI should run the job.
Check your new Review folder if the output is there.
The outputs are going to be in Markdown (.md) format.
You can open it using Notepad (or any other tool that can read & edit markdown files).
Step 4. Check that the route stops when it should
As long as there’s nothing wrong with your request, you can now name a case, send your one-line request, and let the route handle the rest.
But what happens when something IS wrong?
Say you accidentally run the same case twice, or a file is missing.
How do you know the AI won't duplicate the job or make something up?
Your AI Brain has built-in stopping rules for exactly this.
Now you’re going to put them to the test.
Run the same job…again
Open a new chat inside the same project.
Use your one-line prompt again, pointing to the same input file you just tested in the last step.
The duplicate rule should catch it, stop the run, and point you back to the existing result.
Check the Review folder too.
Make sure the AI hasn't quietly created a second result or written over the first one.
Run the job with a missing file (or no file at all)
Ask the AI to make a separate test copy with one required piece of information missing.
Or test with no input file at all.
The AI should stop and tell you that files you named are missing.
Check both the Input and Review folders to make sure it didn’t create anything for this failed attempt.
Step 5. Run one more case
Your route has now passed a real run and a safe-stop test.
Now give it a brand new case, one it hasn’t seen before.
Put the new file in Input.
Send your one-line request and name that file.
Open the finished result in Review.
Check the result before accepting it.
If that all works the way you expect, you’re done testing.
This is the workflow you’ll use for every future case of this job.
That's the whole build, done
Nice work setting up your first job with the AI Brain.
From here on, your AI Brain works more like a personal agent for this part of your work.
It uses the context you’ve already given it, follows the Skill you’ve saved, and improve as you correct and refine how each job should run.
When you’re ready to set up another job in the same project, you already have a head start.
The business context you’re already set up carries over.
Ask the AI for a fresh batch of job ideas (or just tell it the one you already have in mind).
Set the standard for that job, build its Skill, then test its route the same way you did here.
I’m curious what you build next.
Optional help
AI can plan the route but can't run it
Ask what's blocking it and what it needs.
It might read the source just fine but have no way to actually run the Skill, or nowhere to save the result.
Have it walk you through what it can set up inside the project versus what needs you to step in.
You can still use the saved Skill manually, like in Step 1, while you sort this out.
Leave the route marked untested until the full run and both stop tests actually pass.
The duplicate rule is blocking a revision you actually want
Tell AI which result you're revising and what's changed.
Ask how it plans to keep the old version and log the new one before you approve the rerun.
Check the proposed result path.
An intentional revision needs a clear record. so you can tell it apart from an accidental duplicate later.
A run stops halfway through
Ask what AI created and where it save each item.
Have it keep the unfinished work out of Review, preserve any already-accepted results, and tell you exactly what needs fixing.
Once you’ve resolved the problem, approve the retry and review the complete result.
Let the AI keep the failed attempt in the record so you can tell which attempt eventually passed.
Your input files are in an app
Start from a useful export or a pasted chunk of text.
If you're not sure what to hand over, ask:
I use [app] for this information. Tell me the smallest export, report, screenshot, or pasted section you need for this job. Give me the exact date range and fields. Do not ask for information that will not affect the result.
Make sure whatever you hand over actually fits the job.
Screenshots need readable text, and speech-to-text needs a quick pass for wrong names and numbers.
You'd rather review the result somewhere else
Use wherever you already check that kind of work.
A new dashboard just gives you one more inbox to forget about.
For a doc or page in another app, name the exact destination and who can get to it. For a task, say whether the result goes in a comment, an attachment, or a linked document, and check if adding it pings anyone.
Writing somewhere else changes something outside the project, so review the destination and permissions before you approve it. Test the actual delivery step and open the link it returns before folding it into the saved route.
If the connection can't create the result there, keep the finished project file and copy it over yourself. Just note that step as manual.
You want the job to start on its own
A schedule kicks it off at a set time. An event kicks it off when something specific happens, like an approved file showing up.
Either one's worth considering once the manual route runs cleanly on real cases. Nail down the exact trigger, input, and review spot, including any account access or running costs involved. Test missing input, duplicates, and interrupted runs, the same way you just did. Check how to pause it, and confirm pausing actually stops new runs.
Automatic starts don't change one thing: sending and publishing still need your separate approval.
