Vol 2, Issue 2 | Jan 14 2026
The Art of Breaking Things Down
Dear Reader,
Last week I introduced the idea of "programming your gaps" — the mental shift from asking "how do I prompt better?" to "what friction in my life can I systematize?"
Today's the practical follow-up: how do you actually break down a problem into pieces AI can help with?
This matters because the most common failure mode I see isn't "picked the wrong AI tool." It's "tried to solve something too big in one go." People ask ChatGPT to "help me be more productive" or "organize my life" and get generic advice they forget by Thursday.
The secret lies in decomposition — breaking a messy problem into smaller, specific pieces. The same skill that makes you a good programmer, project manager, or problem-solver in general.
Two Building Blocks: Skills and Agents
When I build an automation for myself, everything falls into one of two categories. The distinction is simple, and getting it right determines whether something actually gets used or sits there gathering digital dust.
Skills are recipes.
A skill is a set of instructions for a specific task. You run it when you need it, it does the same thing every time, and it doesn't require judgment or creativity. Think of a cooking recipe — you follow the steps, you get the result.
Examples from my setup:
- "Weekly invoice filing" — check mailboxes, download attachments, rename files, move to the right folder
- "Slop detection" — scan a draft for AI-sounding phrases before I publish
- "Morning brief" — pull calendar, tasks, and relevant notes into a summary
Skills are repeatable. You could write them on an index card if you wanted.
Agents are experts.
An agent is a specialized role with context and judgment. You delegate a domain to it, and it figures out how to handle problems within that domain. Think of hiring a contractor — you describe what you need, they bring expertise you don't have.
Examples from my setup:
- "Home-life-ceo" — knows our insurance policies, school calendars, home maintenance schedule, and can answer questions about household logistics
- "Newsletter-writer" — understands Signal Over Noise voice, can draft content that sounds like me
- "Financial-strategist" — connects to my finance software, analyzes spending patterns, spots budget gaps
Agents are contextual. They accumulate knowledge and make decisions within their domain.
The Distinction That Matters
Here's the test I use:
If you can write it as a checklist, it's a skill. The task has clear inputs, clear outputs, and the steps don't change based on circumstances.
If it requires understanding context and making judgment calls, it's an agent. The task varies depending on situation, needs interpretation, or benefits from accumulated knowledge.
Most people's instinct is to build agents for everything — it sounds more impressive, more "AI." But skills are underrated. A good skill saves you twenty minutes a week, every week, with zero maintenance. An agent that's too ambitious becomes something you never quite finish building.
Start with skills. Graduate to agents when the domain gets complex enough to warrant it.
A Real Example: Quarterly Tax Filing
Every quarter, I need to organize business expenses for my accountant. Invoices arrive from various vendors — Adobe, Anthropic, Apple, DigitalOcean, a dozen others. They land in different email accounts. Some are PDFs, some are HTML receipts. Some I download, some I forget about.
By the time I sit down to do quarterly taxes, it's (at least) a two-hour scramble. Search email, download attachments, figure out which vendor each invoice belongs to, organize into folders, create a summary spreadsheet etc. Every quarter, same friction, same wasted time.
Last month, I finally stopped just grinding through it and asked: "Why does this keep taking so long?"
The friction was spread across multiple points:
- Invoices sit in email until I remember to deal with them
- I re-identify vendors every time
- I recreate the same folder structure each quarter
- I rebuild the summary spreadsheet from scratch
Each of those is a different type of problem — some are clearly skills, some might be agents.
Decomposing the Problem
Problem 1: Invoices sit in email until quarterly scramble
This is pure automation — capture invoices when they arrive, not when I remember.
Solution: Mail rules. When email arrives from adobe.com, move to Receipts/Adobe. Same for every vendor. The system captures at source instead of relying on my memory.
This isn't even AI. It's just good infrastructure. Sometimes the right decomposition reveals that you don't need AI at all.
Problem 2: Re-identifying vendors every time
This is a lookup problem. I need a mapping from invoice IDs to vendor names. Once created, it never changes.
Solution: A reference file. JSON mapping of vendor domains, invoice patterns, and categories (business vs personal). Create it once, never re-decide.
Still no AI needed — just documentation that persists.
Problem 3: Recreating folder structure
The structure is the same every quarter. Q4 2025 looks like Q3 2025 looks like Q2 2025.
Solution: Template. Could be a skill that creates the folders, could be a shell script, could be a template I duplicate. Doesn't matter — the point is I'm not reinventing it.
Problem 4: Weekly filing instead of quarterly batch
Here's where a skill makes sense. Instead of scrambling once a quarter, file invoices once a week. Five minutes weekly beats two hours quarterly.
The skill: Check Receipts mailboxes, download new attachments, rename with consistent format (YYYY-MM-DD_Vendor_Filename.pdf), file to the right folder.
This is a recipe — same steps every time, perfect skill candidate.
What About an Agent?
You might be wondering: shouldn't I just build a "Finance Agent" that handles all of this?
I considered the same thing myself, and my answer is: not yet.
An agent makes sense when:
- The domain is complex enough to need judgment
- Multiple related tasks benefit from shared context
- The problem evolves and the agent can learn
Right now, my quarterly tax prep is straightforward once the friction is eliminated. The weekly filing skill handles capture, the reference file handles vendor mapping, and the remaining work is mechanical.
If I later find myself asking complex questions such as — "Which subscriptions could I consolidate?", "What's my effective hourly rate after expenses?", "Where am I overspending?" — then a Finance Agent starts to make sense. It could hold context about finances and then make connections across different data sources.
But premature agents are a trap. They take longer to build, require more maintenance, and often do less than you imagined because you didn't really need all that capability.
The principle: Start with skills, graduate to agents when the domain earns it.
Your Decomposition Practice
Apply this to your own friction points:
Step 1: Pick something that annoys you regularly.
Not "be more organized" — something specific. "I spend 30 minutes every Monday morning finding what I need to focus on." "I can never find that reference document when clients ask." "I keep recreating the same email response."
Step 2: Ask why it's annoying.
List the actual friction points. Usually there are 3-5 specific things contributing to one general feeling of frustration. Separate them.
Step 3: For each friction point, ask: is this a recipe or a judgment call?
- Recipe → Skill candidate
- Judgment call → Agent candidate (but consider if a simpler solution exists first)
- Neither → Maybe just needs documentation or infrastructure, not AI
Step 4: Start with the smallest piece.
Build one skill. Use it for two weeks. See what friction remains. Then decide on the next piece.
This is slower than trying to build everything at once, but it actually works. Every skill you build is one less thing consuming mental energy. The compound effect is real — but only if you ship small things consistently instead of planning big things indefinitely.
The Payoff
My Q1 2026 tax prep should take less than 30 minutes because:
- Invoices are already filed weekly (skill handles this)
- Vendor mapping exists (reference file handles this)
- Folder structure is templated (infrastructure handles this)
- All that's left is currency conversion and final review
That's the decomposition payoff. A two-hour quarterly grind became a five-minute weekly habit plus a 30-minute quarterly wrap-up.
Not because I found a magic AI tool. Because I broke the problem into pieces and solved each piece with the right level of solution — and it's that kind of thinking that will help you work with agentic AI in the future.
Your Homework
Same question from last week, now with a sharper lens:
What recurring friction could you decompose this week?
Don't try to solve the whole thing. Identify 3-5 specific friction points within the general annoyance. Then pick the smallest one that's clearly a recipe.
Build that one thing, see how it feels.
If you want to share what you're decomposing, hit reply. I read everything, and sometimes your friction points become future newsletter examples (with permission).
If you want guided support making this transition, I'm offering implementation coaching at signalovernoise.at/coaching. We work through your specific friction points together and build the first few skills that actually stick.
Elsewhere
A few things I shipped to GitHub this week:
Minervia Starter Kit v1.1.0 — A co-operating system for human-led knowledge work (as mentioned last week). Minervia as a concept is terminal-native AI that treats your Obsidian vault as persistent memory. And it's interesting timing: Anthropic just announced Claude Cowork in a Research Preview for Max users, which is heading in a similar direction — desktop automation, persistent context, AI that can actually do things on your machine. Minervia's been exploring this territory from the terminal side. Different interface, same insight: stateless chat isn't enough.
Claude Lessons Learned — A skill for structured retrospective analysis. When things go wrong, the typical response is quick fixes that don't address root causes or "be more careful next time" (which doesn't work). This skill runs a 7-phase post-mortem: timeline, root cause analysis, factor identification, and — critically — actual implementation of fixes, not just recommendations.
Claude Agent Borg — An agent that analyzes external Claude/Obsidian setups and integrates their best features into your system. You see someone's Claude Code setup online and want that feature — but copying and pasting creates problems (naming conflicts, missing dependencies, adaptation overhead). This agent handles the systematic assimilation.
All MIT licensed, all designed for the "integration over capability" philosophy I keep writing about.
Until next week,
Jim