16 Patterns to Compound Your Leverage

The tools matter less than the decisions about what goes where and why. Before you accumulate files and systems, answer these questions:

• Where does raw capture go?
• Where does refined/structured stuff live?
• What's working memory (active, in-progress)?
• What's the knowledge base (reference, long-term)?
• What does AI always have access to vs. what do you pull in when needed?

The Kitchen Analogy:

• Countertop — What you're actively working with right now (working memory, current project context)
• Fridge — Things you need frequently, fresh, rotating (active projects, recent thinking)
• Pantry — Stable ingredients you pull when needed (reference docs, frameworks, design systems)
• Freezer — Long-term storage, still accessible but not daily (archives, past projects, idea backlog)

AI needs text to work with. The more relevant text you have, the more it can do for you. Most people are context-starved—they sit down with AI and start from zero every time.

The shift: Creating written artifacts as *inputs* for future leverage, not just as final outputs.

Ways to build your corpus:

• Voice → transcription (low friction, high volume)
• Meeting recordings → text
• Emails, Slack, docs you're already producing → captured and indexed
• Journaling, thinking out loud, verbal processing → saved
• Screenshots → described and extracted

If AI is only available in one mode or one place, you'll only use it in that context. Real leverage comes from AI being accessible across:

Surfaces:

• Phone (capture on the go, voice notes, quick questions)
• Computer (deep work, complex tasks, artifact creation)
• Cloud/integrations (automated workflows, background processing)

Input modes:

• Voice (lowest friction for capture, thinking out loud, hands-free)
• Keyboard (precision, editing, structured work)
• Camera (screenshots, documents, real-world input)

Why it matters: Ideas don't wait for you to be at your desk. The friction of "I'll do that later when I'm at my computer" kills momentum and loses context.

These are two related but distinct requirements:

Sync — Automatic propagation:

Do the work once, and it propagates where it needs to go. Update a doc in Obsidian → it's already available to your Claude Project via GitHub. Capture a voice note on your phone → it lands in your corpus automatically.

Centralized Access — Known addresses:

You don't need everything in one place. You need everything *reachable* from wherever you're working. GitHub as a hub is a good example: things can live there, and many tools can connect to it. You go to the work; you don't move the work to you.

Why both matter:

• Without sync: You become the glue, manually keeping things consistent
• Without centralized access: You waste time hunting, or recreate things that already exist

Most people try to go straight to the structured output. They open a doc and try to write the strategy. They sit down to make the decision. But they haven't externalized enough raw material yet to work with.

The verbal vomit phase does something specific: it gets the *unformed knowing* out of your head (or a team's collective heads) into a form that can then be shaped.

The flow:

The core structure: One document holds the lens (strategy, framework, criteria). Another holds the raw material to evaluate. The AI engine applies one to the other.

The power is in the separation:

• The strategy doc becomes reusable—run different sources through the same lens repeatedly
• Or flip it: same source, different strategy docs, different insights

Where it goes:

• Simplest version: Bring your strategy doc, bring your source, get analysis
• Evolved version: The strategy doc itself improves based on learnings from each use
• Advanced version: Feedback loops that say "based on the last 5 things you evaluated, here's a pattern you might want to add to your strategy"

The traditional flow has a high cost of being wrong early: Designer spends days → Team reviews → "Not quite" → Repeat.

The new flow front-loads exploration at near-zero cost: AI generates 5-10 rough prototypes in minutes → Team reacts to real things → Alignment happens faster → *Then* humans invest skilled time.

The key insight: The prototype isn't the deliverable. It's a *communication artifact*—something concrete enough to react to, cheap enough to throw away.

Where this applies beyond UI:

• Writing: Generate three rough drafts before committing to one structure
• Strategy: Prototype three positioning options before the offsite
• Pitches: Generate multiple angles before refining the deck
• Hiring: Draft several job descriptions to surface what you actually want

There are two costs to building a useful system:

Most people either skip capture because organization feels too heavy, capture into a junk drawer that becomes useless, or spend real time doing the filing work themselves.

Your pattern collapses this: Capture is just a toss. AI does the filing.

What AI does:

• Receives raw input (a domain name, an idea, a note)
• Reasons about what it is and what it's for
• Finds the right place in an existing structure
• Writes it there with appropriate metadata
• Connects it to related things already in the system

Most people regenerate quality from scratch every time. They prompt for a landing page, get something generic, then fight with it to match their brand or taste.

The better approach:

The design system becomes a *reusable constraint*—it narrows the output space to things that already meet your standard.

The traditional approach: You work on something, and occasionally you go to AI with a specific question or task. AI is a tool you visit.

Your approach: The project *lives* in a shared space with AI from day one. AI isn't consulted—it's present. It holds the context, the history, the evolving thinking.

What this looks like:

The shape of a life using this pattern: You have a constellation of containers—each project, area of life, or ongoing concern has a place where thinking accumulates and AI is always caught up.

You have knowledge, context, and preferences that AI needs to help you well. But extracting that from yourself is hard. You don't always know what's relevant.

AI is very good at this extraction. It can ask the right questions, follow up on interesting threads, push where you're vague, and keep going until the picture is complete.

Key tip: One question at a time. When AI dumps a list of 10 questions, it's overwhelming and you give shallow answers. When it asks one, waits, then asks the next based on your response, you go deeper and it gets better signal.

Variations:

• Pre-project interviews: Before starting work, get aligned
• Preference interviews: Capture how you like things done
• Decision interviews: Surface your criteria before choosing
• Reflection interviews: After something ends, extract what you learned

The old assumption: You need to know what you want and how to ask for it before you start.

The new reality: You can start with confusion, with fragments, with "I think I want something like..." and let AI help you find the shape.

What this looks like:

• "Here's a messy dump of what I'm trying to do. Help me turn this into a clear request."
• "I don't know how to structure this. What would you need from me to do this well?"
• "What's possible here that I'm not seeing?"

The old habit: Every new task starts fresh. Open a doc. Stare. Begin.

The new practice: Before you create, ask—what already exists that I can start from?

Sources of non-zero starting points:

• Templates you've built or saved
• Past work on similar problems
• Your corpus (all that written context you've been building)
• Design systems, frameworks, captured strategies
• AI's own knowledge ("What's a good structure for this kind of thing?")

The reframe: Starting from scratch feels virtuous but it's actually expensive. The leverage move is: "What's the fastest path to a solid draft I can react to?"

When you solve a problem once, you can either have a solution (works for this case) or have a *capability* (works for this case and every similar case going forward).

What makes something a packaged capability:

The shift in thinking: Instead of asking "How do I solve this problem?" ask: "What capability would solve this problem *and* others like it?" Then build that.

Part 1: Build the blocks.

Don't just solve problems—create modular pieces that can snap together.

Where blocks come from:

• You build them
• You buy them (tools, APIs, services)
• You find them (templates, open-source, shared resources)
• You hire them (people, services that become callable capabilities)

Part 2: Combine them into configurations.

A project isn't one thing—it's an assembly of blocks snapped together.

The compounding angle: Right now, you might need 5 blocks to do something. As AI improves, those 5 blocks collapse into 2, or into 1. If you've already built the blocks and understand the configuration, you benefit immediately when the tech handles more automatically.

The mindset: Think in systems, not solutions. Build in blocks, not monoliths. Expect consolidation, and be ready for it.

The best way to learn how to get leverage from AI is to use it for *yourself* first—not a client, not a team, not an abstract use case. You.

Why personal first:

• You're the only user, so feedback is immediate
• You feel the friction directly
• You notice what works and what doesn't without needing anyone else's input
• You build intuition that transfers to every other context

The evolution expectation: Your system *will* change. That's not failure—it's the process. What works in month 1 gets refined in month 3. The goal isn't to get it right. The goal is to get it running and keep improving.

The template on-ramp: Don't start from scratch. Adopt a template someone else built. Fork an existing system and customize. Use a starter framework and fill it in. The template isn't the destination—it's the starting line.