Moving Parade was born in the agentic era. We tell time by model releases, not quarters, so it feels like a decade. It's been about a year since we came out.
In that year two founders who aren't software engineers have opened about 1,700 pull requests and built the application we run the agency on: the Hub, where our team runs client work, and the Portal, where clients review and approve it. We're just getting started, and every model release makes us bolder about what to try next. It's a good moment to write down what we've learned.
Here it is.
1. Plan for capabilities you can't unlock yet
The models keep getting better, faster than any roadmap we've written. We build as if the next one will do what this one can't, and we assume that at some point the improvements start compounding on themselves.
In practice that means building the test before you need it. Every report type we produce has a set of golden examples: three to six reports we'd hand any client with pride. Every new output gets scored against them and goes around again until it clears the bar. When a new model ships, we run it against the goldens before we touch anything else. In an afternoon we know what got better, what got worse and what we can stop doing by hand.
Without goldens and scoring, all you can say about a new model is that it feels better.
2. Log everything, even what you don't need yet
Capture every bit of data you can. AI is very good at pattern matching, and it will find correlations across data sets you'd never think to put side by side. The more you've kept, the more it has to work with.
We record every meeting in Granola, and the transcripts land in our database at 2 AM. Every skill run is logged: who ran it, for which client, and whether someone had to redo the output. Every campaign change goes into an optimization log with the hypothesis behind it and a date to check back. Our Harvest time syncs to Supabase every day.
Honest note: most of that data hasn't paid off yet. We keep it because storage is cheap and you can't go back and log last March.
3. Invest in context, and annotate where it's missing
An agent is only as good as what it knows about the account when it starts. Give it everything you can: email, Slack threads, call transcripts, documents.
Every client has a context file our agents read first. At 7 AM a sync reads what changed overnight in Slack, Gmail, Drive and Granola, pulls out the facts, dates each one, notes where it came from and adds it to the file. Anyone on our team can edit or dismiss a fact in the Hub.
Then annotate, especially where the record is silent. The data says a campaign paused on the 14th. It doesn't say the client asked us to pause it because their product launch slipped. If nobody writes that down, the next agent guesses, and so does the next person. Before the sync existed, someone re-briefed an agent at the start of every job. That time now goes into writing down the why.
4. We spend most of our time making AI not sound like AI
This one surprised us. Models write fluently now. The hard part is getting them to stop writing like a model.
Our first move was a long list of don'ts: banned phrases, banned sentence shapes, no em dashes. The list kept growing and the writing got stiffer. Give a model enough rules and its output reads like it was written to pass a checklist, because it was. In July a client document passed our automated filter with zero flags. A second read, by an agent that started from our written voice standard instead of the list, found 18 problems in it.
So Eric rebuilt the standard from how he actually writes: his own decks, emails and posts, with far fewer prohibitions. In blind head-to-head tests on November 5, drafts written to the new guide beat drafts written to the old one 20 times out of 21.
We also score every output on how human it reads, using a rubric we pieced together from a few open-source frameworks. If it lands below the threshold, it goes around again.
5. Give everyone a seat at the vision table
Our system changes every week. Asking a team to keep adopting something that keeps changing under them is a hard sell, unless part of it is theirs.
So everyone gets a say in what we build next. Palmer, one of our media managers, designed the agent that will own our task board. The idea came out of his own week: he knew where tasks went stale because he was the one chasing them. People who helped design the system use it, tell us what breaks and teach it to the next person who joins.
6. Start with data-rich, objective, repeatable work
AI is still weak at original thought. It misses cultural nuance. Even with all the context we can give it, it doesn't fully get the grey areas: who has a reason to say what, what a decision will cost someone, what a client meant versus what they said.
So we point it at work that has data and a right answer: analysis, reports, decks, pacing checks, trafficking sheets. Even there it needs a person. A Performance Max build once pulled "New Jersey" out of a campaign name and wrote ad copy about pricing "in Jersey." It was about 90% right and saved about seven hours, and someone still had to read it.
The big calls stay with people. Whether we sell demand generation systems or AI systems took Eric and me most of an hour on a call in August, and no model was going to settle that for us.
The math for us: about 75% of the tasks on our boards are done by people or need heavy human intervention. The 25% that AI handles gives us back weeks of time every month.
7. If you have an idea, build it right away, at least as a mockup
A working prototype now costs close to nothing plus an hour or two of your time. Skip the debate about user stories and back-end tradeoffs. Build it and see if you like it.
When I wanted a hover effect on the service cards on our new homepage, I tried three versions in one afternoon. My notes on them were "super fake," "doesn't work" and "looks stupid," in that order. The fourth one shipped. The funnel calculator and the channel mix benchmark on our site both started as mockups someone built because they wanted to see the thing. Most mockups die, and that's fine. They cost an hour.
8. Delete scaffolding as fast as you build it
This is the flip side of #1. Half of what you build to cover a model's weaknesses becomes dead weight once the next model ships: the instruction that says to double-check the date math three times, the review step that catches a mistake the model stopped making.
Audit your skills and prompts at every release. When Opus 5 came out in July we went through our whole skill library and kept finding instructions written for the previous model's mistakes. Treat each new model as a migration, not an upgrade. It behaves differently, not just better, and old workarounds can make it worse.
9. Your edits are the best training data you have
The gap between what the AI drafted and what a person actually sent is the ground truth about what good looks like. Capture it on every output.
Every review page we pass around carries an edit layer. When someone on our team, or a client, rewrites a sentence in place and hits approve, the edit goes back to the Hub next to the original. Over a few months that becomes a record of exactly what our people change, for which clients, in our voice. No benchmark you can download knows any of that.
10. Count closed loops, not skills
We have more than 80 skills. That isn't a moat; anyone can write 80 prompts. What counts is the loop around them: route the work to the right agent, check the output, feed the result back in.
We learned this slowly, by building a different checking step for every kind of output. Now there's one standard loop. Each report type has its golden examples and, where a client needs it, a client-specific override. Every output is scored, fixed and scored again until it passes, and every round is logged. A new report type plugs into that loop instead of getting its own.
11. Don't let AI act faster than the signal is valid
An agent can optimize a campaign every hour. The data can't tell you anything true that fast. A B2B LinkedIn campaign might produce eight leads in a week; change the bids on Tuesday because of Monday and you're reacting to noise.
We split it by what the data can actually tell you. Spend is a fact, so we check it every hour. This summer two campaigns sat at $0 for five days because our alerts watched cost per lead and click-through rate, and a campaign spending nothing has neither. Now an hourly check compares every client's spend with the plan. Performance is a statistic, so changes wait for enough data, and each one goes into the log with a hypothesis and a date to look again.
12. Baseline before you automate
Measure how long tasks take before AI touches them. Otherwise "weeks of free time" is a feeling, not a number, and you can't tell which automations earned their keep.
We learned this one by not doing it. In June we found that a lot of us weren't logging time in Harvest consistently, so our before numbers for much of the early work are estimates. Our time now syncs to our database every day, and a new automation gets a before measurement first. The 25% in #6 is real. How many hours it saves is still partly a guess, and we'd rather say so.
Ask me in a year which of these held up.
Tell us where you are. We’ll tell you what we can do.
