Vol 2, Issue 4 | Jan 28 2026
The Orchestration Loop
Dear Reader,
January has been dense.
We've covered the shift from prompting to orchestration, the art of decomposing problems into skills and agents, and the metric mandate that keeps projects honest. If you've been following along, you've got three powerful ideas — but they might still feel like separate concepts sitting next to each other.
They're not. They're a loop.
By the end of this issue, you'll have a checklist you can apply to your first orchestration project. Not theory — a practical workflow you can start using this week.
The Loop
Here's how the three concepts connect:
Each piece of this series addresses a specific phase:
The loop is the missing piece. It’s what turns three good ideas into a repeatable process.
A Real Example: Weekly Inbox Processing
Let me show you how this works with something most knowledge workers deal with — the weekly pile of captured notes, saved articles, and half-formed ideas that need to go somewhere.
Step 1: The Metric
The friction: my inbox folder. Notes from meetings, articles I’d saved to read later, voice memos, random thoughts captured on my phone. Every week it grew. Every few weeks I’d spend a Sunday afternoon sorting through it, feeling vaguely guilty about everything I’d forgotten.
That’s the number: time spent processing the weekly inbox.
Baseline: 90-120 minutes, usually procrastinated until it became overwhelming.
Target: Under 30 minutes, done consistently every Friday.
Kill criteria: If I’m still dreading it or skipping weeks, the automation isn’t solving the actual problem.
Step 2: Decompose the Friction
Where was the time actually going?
- Classification — figuring out what type of thing each item is (task, reference, project note, someday/maybe)
- Destination decisions — where does this belong in my system?
- Action extraction — pulling tasks out of meeting notes and random captures
- Filing — actually moving things to the right folders
- Pruning — deciding what to just delete
Some of these are recipes. Some need judgment.
- Classification → Skill. Clear categories, consistent rules. Same logic every time.
- Destination decisions → Mostly skill. My folder structure is documented. Most items have obvious homes.
- Action extraction → Judgment call. Requires understanding context and priorities.
- Filing → Skill. Once I know where something goes, moving it is mechanical.
- Pruning → Judgment call. Only I know what’s actually worth keeping.
Step 3: Build the Smallest Piece
I started with classification — the most mechanical part.
A skill that reads each inbox item and tags it: task, reference, project-related, or archive. Clear inputs, clear outputs, same rules every time.
One skill. Took an evening to build. Immediately useful.
Step 4: Integrate
The classifier doesn’t export to some separate app. It reads directly from my inbox folder, adds tags to the files in place, and leaves them ready for the next step. When I open my Friday review, everything’s already sorted — I just need to make decisions about the judgment-call items.
That’s the shift in action: tools that work with your existing system, not parallel to it.
Step 5: Measure
After a month: inbox processing dropped to about 25 minutes. More importantly, I stopped skipping weeks. The friction that made me procrastinate was the “figuring out what this is” phase — once that was handled, the rest felt manageable.
Success on that piece. Move to the next.
Loop Back
The filing skill came next — once something’s classified, put it in the right place automatically. Then a simple action extractor that flags anything that looks like a task.
Each piece built on the last. Each one measurable. Each one integrated into the same workflow.
Current state: Friday inbox processing takes 20-30 minutes instead of being a dreaded Sunday chore. The metric moved. The approach works. Keep iterating.
The Checklist
Here’s what this looks like as a repeatable process:
Before You Start
- What specific number will change?
- What’s the baseline today?
- What’s minimum success?
- When will you measure?
- What triggers stop?
If any of these are blank, you’re not ready.
Decomposition
- What are the 3-5 friction points?
- For each: recipe (skill) or judgment call (agent)?
- Which is the smallest useful piece?
- Can anything be solved with just documentation or infrastructure?
Build & Integrate
- Does this connect to your existing files/notes/context?
- How will outputs feed back into your system?
- What’s the minimum viable version you can ship this week?
Measure & Iterate
- Did the number change?
- What friction remains?
- What’s the next smallest piece?
Print this. Use it. The questions matter more than the format.
The Mistakes I Keep Seeing
Four patterns that can derail orchestration projects:
Starting with agents instead of skills. The allure of building something that “thinks” is strong. But agents are harder to build, harder to debug, and often unnecessary. Start with recipes. Graduate when the domain earns it.
Skipping metrics. “Improve my workflow” isn’t a goal. If you can’t define what improvement looks like, you can’t know if you’ve achieved it.
Building standalone tools. A skill that exports to a separate folder, requires manual import, or doesn’t connect to your existing notes is a skill you’ll stop using. Integration is what makes things stick.
Trying to solve the whole problem at once. The compound effect is real, but only if you ship small things consistently. A five-skill system you build over two months beats a twenty-skill system you never finish.
Your Assignment
- Pick one recurring friction in your work.
- Run it through the checklist.
- Start with the smallest piece.
That’s it. Not “build a system.” Not “design your workflow.” Pick one thing, apply the loop, ship something small.
If you want guided support making this transition — someone to help you identify the right friction points and build the first few pieces — I offer implementation coaching. We work through your specific situation together.
But the core insight doesn’t require coaching: metrics → decomposition → integration → measure → repeat.
The loop works. Use it.
What’s Next
This wraps the January Orchestration Arc. Four issues, one framework:
- Programming Your Gaps — from prompting to orchestrating, from sessions to systems
- Breaking Things Down — skills (recipes) vs. agents (judgment), start small
- The Metric Mandate — five questions before any project starts
- The Orchestration Loop — how the three connect into a repeatable workflow
February will explore new territory. I’ve got some ideas brewing — but I’m curious what questions this series raised for you. What’s still unclear? What would help most?
Hit reply. I read everything.
Until next week,
Jim
Elsewhere
Something I shipped this week:
The AntiSlop — A Claude Code skill for catching AI writing patterns before you publish.
Detects 35+ tells across content, language, style, and structure — including structural patterns like staccato fragments and "This isn't X, it's Y" comparisons that phrase-based detectors miss. More importantly, it actually fixes problems rather than just flagging them. Useful if you're using AI to assist with drafts and want the output to sound like you wrote it.
MIT licensed. Use it, fork it, improve it.