The 10-80-10 rule is a way to delegate: you spend the first 10 percent of the effort writing the brief, the person or AI does the middle 80 percent without you, and you spend the last 10 percent on one review against the criteria you wrote at the start. I use it on my own agency work, and my task system runs on it, with an AI agent doing the 80.
Most delegation goes wrong at the first 10. The brief is a Slack message, the work comes back wrong, and three rounds of “close, but” follow. This post shows what goes in the brief, why the middle stays untouched, and how the final pass works.
Delegation is a lever on a bigger problem, and the problem itself is worth naming before you pull it. If you’re not sure it’s the one, start by finding what’s holding your agency back.
Why most projects spiral (and how to stop it)
Let’s not kid ourselves about what usually happens. Most projects go sideways because phase one is starved for context, everyone sprints headfirst into execution mode, and then review turns into a chaotic triage situation. The 10-80-10 Rule completely flips this formula.
Here’s how it breaks down. You spend 10 percent of your effort building a solid “context packet” with real acceptance criteria. Then you hand off 80 percent for free-range execution where people actually get to work. Finally, you wrap with a laser-focused 10 percent revision pass. The result? Faster progress, way less backtracking, and work that doesn’t quietly mutate into something unrecognizable.
If faster, higher-quality work with fewer messy do-overs sounds good, you need to front-load context, let your people and machines actually work, and put your energy into one sharp round of revision. That’s the 10-80-10 magic.
The beauty is this works equally well whether you’re delegating to your senior designer or prompting ChatGPT to write email sequences. Let me show you how.
1. Build a powerful context packet (the first 10 percent)
Nothing tanks a project faster than an empty brief. Or worse, an email that can only be described as “vibes-based delegation.”
The magic starts by actually front-loading your context packet. Take the first 10 percent of any assignment to nail down the purpose, constraints, target audience, and what success actually looks like before you hand it off. I’m talking about using prompt scaffolds or a battle-tested template to capture the what, why, and how. Bonus points if you include both shining examples of what you want and horrifying examples of what to avoid.
For human team members, ditch the vague Slack DMs in favor of visual checklists and properly documented requirements. For AI, define your must-haves clearly and specify output format, tone, and length constraints before you hit send. Think of this as insurance against that dreaded “wait, that’s not what I meant” conversation that happens three days and six revisions later.
A bulletproof kickoff eliminates guesswork and stops endless clarification rounds before they start. When I started front-loading context like this, I cut revision cycles in half almost immediately. The time invested upfront pays for itself three times over.
2. Let the work breathe (the autonomous 80 percent)
Here’s where most managers and agency owners completely blow it. If you want quality results, you have to resist the urge to hover or “just double-check one tiny thing” every five minutes.
The gold is in letting the doers actually do the work. Once you’ve front-loaded your requirements and acceptance criteria, step back and let your humans or robots run the show for the next 80 percent. No ninja route changes. No micromanagement marathons. No pop-in feedback sessions “just to align real quick.”
For a 60-minute job, that means around 48 blessed minutes of uninterrupted focus. Not a Slack attack every three minutes asking for a status update. Skip the friendly drive-by feedback unless someone’s actively careening off the rails toward disaster.
This is where real work actually happens. Deep thinking, creative problem-solving, and meaningful execution only emerge when people have solid blocks of uninterrupted time. This is how projects move from “in progress” to “actually finished.”
I know it feels uncomfortable at first. Trusting people and machines to spend real time working instead of constantly justifying their progress feels risky. But it’s actually a low-key productivity power move that changes everything.
3. Surgical revision pass (the final 10 percent)
It’s incredibly tempting to wrap up projects with a never-ending feedback spiral where you find new things to tweak on every pass. But why not cut straight to “done” with a single, targeted revision?
Save the last 10 percent (say, 6 minutes out of an hour-long task) for a crisp review using an actual checklist and those acceptance criteria you defined upfront. No writing dissertation-length feedback documents. Just direct, specific call-outs: what works, what doesn’t land, what needs a quick two-minute fix.
For AI outputs, bake prompt templates into your workflow that force an explicit yes or no on all deliverables. Did it check every box? Did it match your example output or stumble somewhere weird? Be ruthlessly specific.
Mark what’s unclear once, document it clearly, and only run another full round if disaster truly strikes. The goal here is surgical precision, not death by a thousand tiny cuts.
When you approach revision with this kind of focus, you lock in quality without starring in “Rework: The Sequel.” I’ve found that one focused revision pass catches about 90% of what I’d eventually find across three or four casual review rounds, and it takes a fraction of the time.
How I use the 10-80-10 rule with AI agents
I stopped treating this as a tip and started treating it as the system. Every task I hand to my AI agents follows the same three phases.
The first 10 percent is the brief. Before an agent touches a task, it reads the task description, the client folder, past calls and the thread where the request came from. It then posts what it thinks the job is, what it is assuming, and where it looked. If two readings of the task would produce different work, it stops and asks me one question. A wrong guess costs a whole draft. A question costs me a one-line reply.
The 80 percent is the work, and I stay out of it. The agent writes the draft into a document. I don’t check in, I don’t send corrections mid-draft, and the agent doesn’t ask for approval at each step.
The last 10 percent is my review, and I get one pass at it. I read the document, leave comments, and either approve it or send it back with changes. Each trip back is counted. Revision rounds per task is the number I watch, because it tells me whether the brief was good. A task that takes three rounds had a bad first 10 percent, almost every time.
The same check works on people. When a contractor’s work comes back wrong, look at what the brief left out before you look at the work.
4. Templates and prompt scaffolding are your secret weapons
Every time you reinvent a brief or write a prompt from scratch, you’re basically volunteering for free overtime in the confusion department. Templates are your escape route.
Lock down your workflow with repeatable structures. Context packet blueprints for the humans on your team. Prompt scaffolding for your AI assistants. Measurable acceptance criteria for everyone. Try it with something simple like a client report template first, then translate the same structure for your AI tool and see which version performs better.
Version these resources somewhere accessible. Your wiki, Notion, whatever works for your team. It shouldn’t be a treasure hunt every time someone needs the project brief template. Start with basic structures: project brief template, revision checklist, AI prompt framework. Then build from there as you discover what works.
The smartest agencies I know build libraries of proven templates that get refined over time. Each successful project becomes a blueprint for the next one. New team members can hit the ground running. AI outputs get more consistent and useful.
A growing library of battle-tested templates makes every handoff snappier, clearer, and dare I say it, almost fun. Okay, maybe not fun. But definitely less painful.
5. Make results measurable (track what matters)
If you can’t measure something, you’re basically trusting vibes. And we both know how that usually goes.
Track the metrics that actually matter so your 10-80-10 approach translates into measurable results. Keep an eye on rework cycles (how many times did you have to send something back?), number of revision rounds before approval, and how long work sits in the “almost finished” purgatory stage.
For AI specifically, count how many attempts it takes to get a usable blog outline or social media calendar. Lower numbers mean your context game is strong. Higher numbers mean your “just enough” brief is, well, not nearly enough.
Use these numbers to tune your templates over time. Track time-to-completion, revision cycles, and client satisfaction scores. And maybe, just maybe, celebrate when something hits approval on the first try without needing changes.
Hard numbers turn the 10-80-10 Rule from wishful thinking into a true productivity engine. I started tracking revision cycles about six months after implementing this approach, and watching that number drop from an average of 3.8 revisions per deliverable to 1.2 was genuinely satisfying. Your mileage may vary, but the trend should be similar.
Why most delegation methods fail (and how 10-80-10 fixes them)
Traditional delegation typically falls into two camps, and both are broken in their own special ways.
First, you have the under-briefers. They toss out assignments like confetti at a parade and then genuinely wonder why everything comes back wrong. Their briefs consist of “can you make this more engaging?” or “we need a blog post about AI” with zero additional context.
Then there’s the over-briefers. These folks write novels, hold three alignment meetings, create seventeen-slide decks explaining the project, and still end up with work that completely misses the mark. Why? Because the brief was too complex and contradictory for anyone to actually follow.
The 10-80-10 Rule hits that elusive sweet spot between these extremes. You get rich context without overwhelming detail. Autonomous execution without total abandonment. Focused revision without perfectionist paralysis.
It works because it mirrors how humans actually process information and get things done. We need enough context upfront to understand the goal and constraints. We need space to think, create, and solve problems without constant interruption. And we need clear, specific feedback to refine the output without spiraling into endless revision hell.
Adapting 10-80-10 for different project types
A website redesign needs wildly different context than a social media campaign, but the underlying principle absolutely holds. You just adjust what goes into each phase.
For creative projects, your context packet might include mood boards, competitor examples, brand guidelines, and specific design constraints. For analytical work, provide data sources, methodology preferences, output format requirements, and decision criteria.
AI prompts benefit hugely from role-playing setups like “Act as a senior B2B copywriter with 10 years of SaaS experience.” Add specific constraints such as “Write exactly 3 headline options, each under 60 characters.” Then layer in success metrics like “Headlines should emphasize cost savings and time efficiency over feature lists.”
The beauty of 10-80-10 is its flexibility across project types and team structures. Scale the context to match project complexity, but always maintain that rhythm of thorough setup, autonomous execution, and focused revision. I’ve used this framework for everything from 15-minute blog post edits to three-month website overhauls. The principle scales surprisingly well.
Your implementation game plan
Every project gets easier and shockingly faster when you front-load context, trust the process, stick to a single ruthless revision pass, and let the endless chaos live somewhere else for a change.
When you actually commit to the 10-80-10 Rule, things shift noticeably. Work gets done faster. Quality goes up. The number of existential sighs during your weekly standup meeting drops dramatically.
Here’s your move: document your own context packet template and revision checklist this week. Then pilot the approach on one real project. Start small with something manageable like a blog post or social media campaign. Test it, refine your templates based on what you learn, then scale up to bigger, more complex projects.
The framework is simple, but the impact compounds over time. Each project that runs smoother makes the next one even better.
Master the 10-80-10 rule with Dynamic Agency Community
Want to compare notes, swipe proven templates, or discuss workflow breakdowns with people who actually get it?
Join the Dynamic Agency Community where agency leaders trade strategies, steal each other’s best templates (with permission), and build better systems together. Because figuring this stuff out alone is possible, but figuring it out with a crew of smart people who’ve been there is way faster.
