This was originally published on All Agents Considered.
Futurism ran a story last week about employees burning their company’s expensive AI tokens on pointless tasks. Amazon staffers were using their mandated AI agent to run personal tasks to hit usage quotas. A single employee at one company spent over $150,000 a month on AI tokens.
Moreover, Uber capped each employee’s AI spending at $1,500 a month after engineers blew through the company’s entire 2026 AI budget.
I did the same thing on a smaller scale, and it cost me three full days before I admitted it. Last week I wrote about reorganizing my files so my agent could find them in thirty seconds, and that gave me the ground to rebuild on. If I were starting over today, the first thing I would do before connecting anything is this one test I skipped.
In this edition I’m going to show you that test, the workflow I use now because of it, and how you can run it on your own setup right now.
In this piece:
A five-minute test that tells you whether a source belongs in your workflow before you waste a day configuring it
The exclusions list that cost me three days to learn but saves me 40 minutes every morning since
A four-file workflow pattern that turned 80% noise into 10 usable article angles per run
The Three Days I Lost to Configuration
When I found Hermes, the first impulse was to connect everything I could think of. arXiv for academic papers, Reddit through the Arctic Shift API for community discussion, RSS feeds for blogs I read, and a cron job to run the whole thing every morning so I would wake up to a fresh batch of research.
Each connection required its own setup, and each setup required its own research.
Arctic Shift needed an endpoint, subreddit filters, and time-range parameters. I had to find the API, read its documentation, figure out the filtering, and test it. That alone ate a full day. arXiv needed category filters for computer science papers, rate limiting so I wouldn’t get blocked, and a custom parser for its XML feed. Another day gone. Then I had to build the Hermes skill that would call both APIs, parse the results, deduplicate across sources, and route everything through my brand filter, which checks whether each item helps someone move beyond ChatGPT toward open source, local, and agentic systems they control. Its skill file alone was 180 lines of configuration listing six sources, a daily cron schedule, and the output format for observations and article angles.
By the time I finished, six sources were wired together and firing on a daily schedule. Less than 20% of the output was relevant to anything I would write about for All Agents Considered. arXiv served academic papers I would never translate for readers, while the subreddits I scraped served social chatter that would never pass my brand filter.
I filtered the noise for a few days thinking I could tighten it, but the bigger loss was time spent on API setup and skill management for sources I never held next to my filter before wiring them in. Building felt productive. Connecting APIs felt productive. Making things run on a schedule felt productive. But none of it produced a single article angle because those sources were never going to fit the work I do.
Every item must support the AAC mission: help AI users become more independent by building open source, local, and agentic systems they control.
I had that filter written down in the skill file. I never held it next to arXiv and Reddit before wiring them in. Instead I built on a wrong foundation for three days and ran the output for another week before I admitted it.
The Test I Should’ve Run First
Open your brand filter or audience description. If you don’t have one, write three sentences about who you serve and what they need. That’s your filter.
Open each source you’re planning to connect. Spend 60 seconds scrolling through what it produces today. Hold that output next to your filter.
arXiv today publishes papers on transformer architecture, reinforcement learning benchmarks, and multimodal reasoning. None of those help a non-coder move beyond ChatGPT. Reddit’s r/LocalLLaMA discusses quantization formats, model benchmarks, and hardware setups. Some crosses into AAC territory, but most assumes a technical reader who already knows what GGUF means. My audience doesn’t.
Most source mismatches are obvious when you see them side by side. People skip the test because connecting an API feels like real work and reading a webpage feels like nothing, so we gravitate toward what looks productive.
If you’re about to wire a source into your AI workflow, run this test right now. Open the source, open your filter, look at both. If the match is weak, put the source on an exclusions list and move on. You saved yourself a day of configuration.
Where the Output Proved Me Wrong
20 to 30 items every morning from 6 sources, and I was spending 40 minutes sorting through them. My brand filter was supposed to do the sorting, but the agent was applying it loosely because the input was too varied. Academic abstracts, Reddit threads, blog posts, and RSS headlines all needed different interpretation, and the instructions weren’t specific enough.
I tightened the filter and added scoring from one to five:
# Scoring rubric
+1 if technical people are discussing it
+1 if it helps people move beyond ChatGPT
+1 if it relates to independence, control, cost, memory,
files, agents, local AI, or open source
+1 if a non-coder needs translation
+1 if it points to a practical setup, workflow, article,
course module, or useful build
Drop anything scoring below 3.
Each rule caught real noise, but each rule was also more configuration on a foundation already wrong.
A daily cron meant the workflow ran every morning whether I needed it or not. Some mornings I hadn’t scanned new sources since the last run, so the output was thin. Other mornings I had a weekend backlog the single daily run couldn’t handle. Every three days to a week would’ve been right, but daily felt productive.
When I subtracted the setup days from the value the workflow produced, the complicated version was worse than no workflow at all. I’d spent more time configuring sources I should never have connected than I would’ve spent doing the task manually for a month. Once I understood that math, I tore the whole thing down.
The Exclusions List That Replaced It
Before I rebuilt anything, I wrote down every source that didn’t serve my work:
# Hard exclusions - sources I don't track as daily inputs
- arXiv
- Semantic Scholar
- Papers with Code
- Hugging Face Daily Papers
- Hugging Face trending models
- Ollama as a standalone source
- Reddit
- X
- LinkedIn
- YouTube
- Discord
- Product Hunt
Every source on that list is fine for other audiences. arXiv is essential for researchers. Reddit is gold for technical practitioners. YouTube is where most people learn about AI today. None of them produce output that helps a non-coder AAC reader move beyond ChatGPT toward systems they control.
Exclusions are where time savings compound. Every source you don’t connect is a day of configuration you don’t spend, an API you don’t debug, and a category of noise you don’t filter every morning. Short list, massive savings.
I wrote about the shift from optimizing prompts to building workflows earlier this month, and the exclusions list is the bridge between those two ideas. You can’t build a workflow until you know what doesn’t belong in it.
What stayed was small by comparison. Hacker News for technical discussion that non-coders need translated. Lobsters for deeper practitioner conversations. A handful of blogs I’ve read for years and trust to stay in my lane. RSS feeds from three newsletters that cover the intersection of AI and personal productivity. That’s the input list, and it fits on a single screen.
Before the rebuild, I was sorting through 20 to 30 items every morning from 6 sources, spending 40 minutes filtering noise. With this list, I paste a handful of links, run the agent, and get 10 usable angles back in the time it takes to make coffee.
The Workflow That Replaced Three Days of Configuration
My rebuild started by asking what the workflow needs to do. Sort raw research notes from sources I trust, score each against the brand filter, keep what passes, turn the best into article angles, and save the result to review with my coffee.
Structure uses the same numbered-folder pattern from my file structure piece, applied to a single workflow instead of a whole vault. Four files in one folder for one task I repeat every few days, with no external APIs, no cron, no routing, and no memory layers. Everything the agent needs to do its job lives in those four files, and nothing else creeps in.
01.Research Sorter/
├── 01.instructions.md
├── 02.input.md
├── 03.output.md
└── 04.review.md
Instructions tell the agent what the workflow is and what it should do, in plain English:
# AAC Research Sorter
This workflow takes raw research notes and turns them into
AAC article observations and seeds.
Read 02.input.md. For each item, apply the brand filter:
- Does this help someone move beyond ChatGPT?
- Does it point to a practical setup or decision?
- Does a non-coder need it translated?
Score each item from 1 to 5. Keep items scoring 3 or higher.
For each kept item, write one observation with a signal,
a plain-English translation, and an article angle.
Write the sorted list to 03.output.md.
Input holds the raw material. Links, titles, one-line observations I jot down while scanning sources I already trust. Everything I dump goes in this file, and the instructions file tells the agent how to sort it. Output receives the result: a dated note with top observations, article angles for each, the best three ideas to write next, and any course or build connections. Review tells me what to check:
# Review Checklist
- Read the best-three list
- Pick one idea to pursue this week
- Flag any observation where the article angle feels generic
- Check whether any item scored too high because the
brand filter was applied loosely
Numbers give the agent its reading order, one concern per file keeps boundaries clear, and every file has one job. When the agent opens the folder, it doesn’t have to guess what to read first or what each file is for.
Three Manual Runs Before You Automate Anything
Before I added anything back, I ran the workflow three times manually. Three mornings of pasting links, running the agent, and checking what it produced. First run had a scoring error because my brand filter instruction was too vague about what counts as practical. Second run turned a pure news item into an observation because the instructions didn’t explicitly exclude vendor PR. Third run was clean.
If I’d added the cron schedule after the first run, I would’ve automated a workflow still broken in ways I hadn’t seen. Running manually three times is what taught me what the workflow does well and where it breaks. One run teaches you nothing because you haven’t seen the variance.
This is where most people go wrong. They build something, it works once, and they schedule it to run forever. Second run catches edge cases the first one missed. Third run proves the pattern holds. Skipping any of those steps means you’re automating a system you haven’t validated, and automation amplifies problems as reliably as it amplifies good output.
You can build this as an agent or skill file, or keep them in your docs as they are and point Hermes to the folder when you’re running the workflow.
Its full version now fetches from nine sources I’ve validated against my brand filter, scores 166 items in a single run, and produces ten article observations with course connections. It runs every few days, not every morning, because that’s the cadence the task needs. I wrote about how this fits into my morning routine, and the Hermes maintenance routine I run keeps it from drifting.
Run This Today
Open your AI workflow. Look at every source it connects to, every API it calls, every feed it reads. For each one, hold the source next to your filter. If the match is weak, disconnect it. Put it on your exclusions list. You freed up the configuration time and morning filtering time that source was costing you every single day.
If you don’t have a brand filter yet, write three sentences about who you serve and what they need. Sources that survive the test are your real input list. Build around those, run it by hand three times, and think about scheduling only after the third run is clean.
Whole process takes an afternoon and replaces weeks of configuration sprawl. Every layer you add after that, whether it’s a cron schedule or a new source, gets added only when the previous one works.
If the broader stack is what you’re after, whether that’s provider routing, memory ownership, or how to build an agent that doesn’t drift between sessions, I wrote the full cost breakdown of the Hermes stack and the morning workflow that runs on it. Both of those depend on the same small-file-loop pattern to stay reliable.
Capability is cheap when the wiring around it is broken. Build the filter first, run it by hand three times, and the capability takes care of itself. One brand statement and a four-file loop is the difference between an AI workflow that wastes your mornings and one that gives you back two hours a week.
Top comments (0)