For Anyone Drowning in To-Dos

Busy Isn’t
the Same as Done

Turn a to-do list into a decided Result, Purpose, and a tightened plan of action, then get coached back into motion when momentum stalls.

A long to-do list feels like progress. It’s usually just proof you haven’t decided what actually matters.

The external problem

You’ve got a list twenty items long, you cleared six of them today, and the thing that actually matters is still sitting untouched at the bottom.

The internal problem

Busy and behind at the same time. Checking things off feels like progress until you notice the list never actually gets shorter.

What's at stake

Months spent on a full calendar and an empty win column. The people who get ahead aren’t doing more, they’re doing the 20% that was always going to matter.

Four steps: name it, find the why, cut it, then move.

Run the full session when you’re deciding what to work on, or jump straight to momentum when you already know but can’t get moving.

01

Result

Name the specific outcome, not the activity, then narrow it to the MVP version, the smallest thing that actually counts as a win.

02

Purpose

Find the real reason underneath the result. Not the object, the why that will still get you moving when it’s inconvenient.

03

Massive Action Plan

Brainstorm every possible action, then cut it down to the ~20% that produces ~80% of the result, filtered by consequence, compounding return, and speed to MVP.

04

Momentum Engine

Break the plan into steps small enough to start in the next ten minutes, then stack small wins until the work carries itself.

Reference library: Three practitioners, one method.

RPM comes from Tony Robbins. The leverage filters that cut the plan down come from Dr. Justin Sung’s work on task prioritization. The momentum engine, why small wins compound into discipline, comes from Nick Tarmossin’s breakdown of high agency.

Supporting reference files follow the practical guide. Archived source material and author workflow notes are not a current policy certification.

01 RPM MethodTony Robbins on naming the Result, Purpose, and Massive Action Plan.

Reference

RPM Method

Metadata

FieldValue
TitleHow to Prioritize: Achieve What You Want
Author / speakerTony Robbins
PlatformYouTube (Short)
URLhttps://youtube.com/shorts/hveyHYugWzA
Video IDhveyHYugWzA
ChannelTony Robbins (channel ID: UCJLMboBYME_CLEfwsduI0wQ)
Original long-form sourceClip from a Kelsey Humphreys interview: https://youtu.be/qzqAvYfYqZU
Published2023-08-04
Duration59 seconds
Engagement (at time of capture)~96,609 views, ~8,110 likes
FormatShort-form clip, no on-screen citations
CapturedThis session, via transcript + metadata fetch
Reliability noteSingle short clip of a larger interview. RPM is Robbins' own long-standing framework (taught for decades in his programs). Treat as an accurate summary of his stated method; it is motivational coaching content, not peer-reviewed research.

What this source contributes to the skill

The core method: RPM — the engine of the whole skill.

Synthesized takeaways

The reframe that starts it all. Stop asking "what do I need to do." Start asking "what do I want." A to-do list answers the wrong question.

RPM is three questions.

  • R — Result. What do I actually want? Name the specific outcome. Robbins' analogy: like raising the RPMs in an engine, getting clear on the result lets you get there faster and with less effort.
  • P — Purpose. Why do I want it? Purpose is more powerful than the object. "I want to be a millionaire" is weak fuel. "I want to provide a home for my mom because we grew up poor" is strong fuel. You can know the object, but you have to know the purpose — it is what actually drives execution.
  • M — Massive Action Plan (MAP). Brainstorm every possibility for what it would take to achieve the result. Then the most important move: pick the ~20% of actions that will produce ~80% of the result.

The failure mode this prevents. Without a result, a purpose, and a tightened plan, you get "addicted to your to-do list" — lots of movement, no achievement. To-dos make you crazy. The shift is from tasks to outcomes, results, the why, and a tightened MAP.

The last step is compression. After brainstorming the MAP, "tighten that baby down" to what is really going to be accomplished. Brainstorm wide, then cut hard.

02 Leverage FiltersDr. Justin Sung’s two filters: consequence of failure and compounding return.

Reference

Leverage Filters

Metadata

FieldValue
TitleDo this to Priorities tasks effectively (title as published, sic)
Author / speakerDr. Justin Sung
PlatformYouTube (Short)
URLhttps://youtube.com/shorts/q3gfjjgZ3uw
Video IDq3gfjjgZ3uw
ChannelJustin Sung (channel ID: UC2Zs9v2hL2qZZ7vsAENsg4w)
Published2023-01-25
Duration48 seconds
Engagement (at time of capture)~16,397 views, ~1,475 likes
Tagsjustin sung, dr justin sung
FormatShort-form clip, no on-screen citations
CapturedThis session, via transcript + metadata fetch
About the authorEx-medical doctor turned full-time learning and self-management coach. Co-founder of iCanStudy. Per his channel description, takes a practical, evidence-based, field-tested approach and has coached thousands of people on time and study management over 10+ years.
Reliability noteShort clip of a personal method. Author positions his broader work as evidence-based; this specific clip presents a heuristic, not a cited study. Treat as a credible practitioner heuristic.

What this source contributes to the skill

The two leverage filters used to cut a brainstormed action plan down to what actually matters.

Synthesized takeaways

The goal: when you spend time on a task, make sure it is the task that delivers the most possible benefit. Two criteria decide that.

Filter 1 — Consequence of failure. Ask: if I don't do this task, what is the consequence, and is it a consequence I can accept or not? This is how you find what is *truly* important versus what only feels urgent. If the consequence of skipping it is acceptable, it is a candidate to cut or defer.

Filter 2 — Compounding return. Ask: does this put me in a better position tomorrow or next week? Does it change my position? Concretely — if I invest 1 hour now, does it save me 2 hours next week? If 20 minutes now saves 30 minutes later, that is a 10-minute surplus I can reinvest, and it compounds like compound interest. Prioritize work that means the future version of you has less to deal with: it makes things easier and more efficient.

The underlying principle. Time is invested, not just spent. The best tasks are the ones a future-you would thank a present-you for doing — they reduce future load and free up time that compounds.

03 High AgencyNick Tarmossin on decomposing goals and building momentum through small wins.

Reference

High Agency

Metadata

FieldValue
TitleHow To: Develop High Agency (caption); spoken: "This is my map on developing high agency"
Author / speakerNick Tarmossin
PlatformInstagram (Reel)
URLhttps://www.instagram.com/reels/DW76kAZCsJF/
ShortcodeDW76kAZCsJF
Account@nicktarmo (verified, ~121,022 followers, 398 posts at capture)
AudioOriginal audio by nicktarmo
Published2026-04-10 (from taken_at_timestamp 1775792098)
Duration~101 seconds
Engagement (at time of capture)~145,482 plays, ~54,445 views, ~7,133 likes, ~528 comments
Caption"How To: Develop High Agency / Break down big things into small tasks and then climb back up the ladder. / Nothing is too big to accomplish."
FormatShort-form talking-head reel, no on-screen citations
CapturedThis session, via ScrapeCreators Instagram post fetch + user-provided transcript
Reliability notePersonal framework from a content creator who states he works in AI in "the global tech capital." Motivational coaching content, not peer-reviewed research. The dopamine/upward-spiral mechanism is presented as a self-model, not a cited neuroscience claim. Treat as a credible practitioner heuristic for execution and momentum.

What this source contributes to the skill

The execution and momentum half of the skill. RPM (source 01) and the leverage filters (source 02) decide *what* to do. This source covers *how to keep doing it* — turning a tightened plan into sustained motion through decomposition, gamified wins, and an iteration loop. It also adds an ambition gut-check at the goal-setting stage.

Synthesized takeaways

Ambition gut-check. Name what you want, then ask one question: does it defy the laws of physics? If not, it is achievable — proceed. If it does, the goal is miscalibrated and needs reshaping. The framing is a permission-granting reality check: almost nothing real is actually impossible, so the bottleneck is decomposition, not feasibility.

Decompose top-down with first principles. Break big, hard tasks into small, easy ones by reducing the problem to its fundamental truths and rebuilding from there. The purpose of decomposition is psychological as much as logical: it lets you focus on one small thing at a time so the big picture stops being overwhelming, and it makes each piece small enough to actually finish.

Gamify to manufacture momentum. Small, frequently-completed steps act as rewards. Each completion produces a small, frequent dopamine release; frequent reward makes the process self-reinforcing — "addicting" in the productive sense. Once that kicks in you build momentum and start an *upward spiral*: visible results sustain motivation, and not wanting to lose or slow those results sustains discipline. Motivation and discipline here are outputs of seeing results, not prerequisites you must summon first. The lever is making the wins small and frequent enough to start the spiral.

Treat failure as data collection. Pursuing the small tasks, you fail often — and that is necessary. You need enough data points to learn what works and what doesn't. Once you have enough: drop what doesn't work, double down on what does, and repeat. Over iterations this builds a curated knowledge base of what actually works for you.

Outsource the curve when time-constrained. The failure-and-iteration loop is slow. If you are under a time constraint, shortcut it by learning from people who already ran the loop — up to and including buying their curated knowledge directly — instead of rediscovering it yourself.

The whole map. Break big things down into their fundamental truths, then climb back up the ladder to accomplish the thing you want. Nothing is too big; it is only insufficiently decomposed.

Use it now. It's free.

Works on all platforms. Pick yours and get set up in under a minute.

Claude.ai

Download & upload in 60 seconds

Download the zip, then open Claude.ai to upload it.

01

Download the zip below. With JavaScript enabled, Claude.ai opens in a new tab if your browser allows it. Otherwise, use Open Claude.ai.

02

Click the + button in the skills column on the left.

03

Select Create a skill.

04

Select Upload a skill and upload the zip.

05

Start your prioritization session by running /estack-productivity-prioritization-coach.

Claude Code

Run one command in any terminal

Works anywhere Node.js is installed — your project directory, home directory, anywhere.

01

Open your terminal app and run this command.

npx elliot-stack@latest
02

Run the command.

03

Start Claude Code by typing claude in your terminal.

04

Start your prioritization session by running /estack-productivity-prioritization-coach.

ChatGPT / Other

Paste a prompt — the AI does the rest

This prompt tells the AI where to fetch current instructions from the live site. No installs. No version lag.

01

Copy the prompt below.

Preview prompt
# Prioritization Coach

This skill turns "what do I need to do" into "what do I actually want, and what is the smallest set of actions that gets me there." It coaches the user through a decision instead of handing them a longer list.

## The core shift

A to-do list answers the wrong question. It produces movement without achievement — you can be busy all week and move nothing that matters. The job of this skill is to pull the user out of task-thinking and into outcome-thinking before they spend another hour.

So when this skill triggers, do not just help the user organize their tasks. Coach them through the method below.

**Two lenses frame everything in this skill.**

First: decreasing the time to any outcome is the most impactful skill for anyone successful. Speed to result is not a nice-to-have — it is the leverage point. A result in two weeks beats a better result in two months, because the faster you ship, the faster you learn, iterate, and compound. Every coaching session should be asking: how do we cut the time to this outcome?

Second: the target outcome is the MVP outcome, not the perfect outcome. The MAP is not a plan to build the best version — it is a plan to build the smallest version that proves the thing works. Perfection is a scope problem masquerading as a quality problem. Shipping an MVP unlocks the next iteration; waiting for the "right" version usually means not shipping at all.

These two lenses work together: MVP scoping is what makes speed achievable.

## Calibrate depth to stakes

Default to actively coaching — walk the user through the questions, one at a time, and make them answer. Do not dump the whole framework at once.

The one exception: if the ask is genuinely small (a single quick task, a five-minute decision), compress RPM into one or two pointed questions rather than running the full ritual. Big decisions — weekly planning, choosing between projects, "I'm drowning" — get the full treatment.

## The method: RPM

RPM is three questions. Coach them in order. Each one has a failure mode to watch for.

### R — Result

**Ask:** "What do you actually want here? Name the specific outcome — not the activity."

The result is the target, stated as a finished state, not a verb. "Get buildpurdue more members" is vague. "200 active members by end of semester" is a result. Push until the answer is concrete and you would both know if it were achieved.

**Failure mode:** the user names a task or an activity instead of an outcome. "Send emails" is not a result. Redirect: "That's an action. What does sending those emails get you?"

**MVP anchor.** Once the result is concrete, ask: "Is this the MVP version of this result, or the ideal version?" Push the user to define the smallest outcome that would count as a win. A useful test: "What would a version that ships in half the time look like?" That version is almost always the real target. Keep narrowing until the result is both concrete and lean.

**Ambition gut-check.** After the MVP anchor, run one fast reality check: does it defy the laws of physics? If not, it is achievable — say so and move on. The point is to grant permission: almost nothing real is actually impossible, so the bottleneck is decomposition and scope, not feasibility. The rare exception is a result that genuinely can't exist as stated ("replace all my income by Friday") — then reshape it rather than letting it stall the user.

### P — Purpose

**Ask:** "Why do you want that? What's the purpose underneath it?"

Purpose is more powerful than the object. A goal stated as an object ("hit $10k MRR") is weak fuel. The same goal connected to a purpose ("prove the startup is real so I can justify going all-in") drives execution. The purpose is also a filter: if the user cannot find a real why, the result may not be worth pursuing right now.

**Failure mode:** the user restates the result as the purpose. Push one level deeper: "That's what you want. Why does that matter to you?"

### M — Massive Action Plan (MAP)

This is two moves: brainstorm wide, then cut hard.

**First, ask:** "Brainstorm everything — every possible action that could move this result. Don't filter yet."

Get a wide list. Quantity first.

**Then cut it down** using the filters below. The output is a tightened MAP: the short list of actions that actually get accomplished.

**Failure mode:** stopping at the brainstorm. A long list of possible actions is still a to-do list. The MAP is not done until it is cut.

## Filtering the MAP

A brainstorm becomes a plan by cutting it. Run the candidate actions through these five lenses and keep only what survives.

1. **The 80/20 cut.** Which ~20% of these actions would produce ~80% of the result? Keep those. This is the primary cut — most of the list does not make it.

2. **Consequence of failure.** For each surviving action ask: "If you skip this, what actually breaks — and can you accept that?" If the consequence is acceptable, it is a candidate to cut or defer. This separates truly important from merely urgent-feeling.

3. **Compounding return.** Ask: "Does this put you in a better position next week? If you invest an hour now, does it save you two later?" Favor actions where present effort reduces future load — that time compounds. Maintenance work that changes nothing about your future position ranks lower.

4. **Quadrant II check.** Important but not urgent work (Covey's Quadrant II — planning, building systems, relationships, prevention) is what gets skipped under pressure and matters most. If the tightened MAP is all urgent firefighting and no Quadrant II, flag it.

5. **Speed-to-MVP cut.** For each surviving action ask: "Does this get me to a shippable result faster, or is it a polish move?" Anything that improves quality toward perfection rather than enabling the result should be cut or deferred to a later iteration. A shippable result with rough edges beats a perfect result that doesn't exist yet. This is the final gate: if the MAP still feels big, ask "what's the version that ships in half the time?" and cut to that.

The end state of a coaching session: a decided **Result** (MVP-scoped), an articulated **Purpose**, and a short, filtered **MAP** — fewer items than the user started with, not more, built around the fastest path to done.

## Building momentum (high agency)

RPM and the filters decide *what* to do. This section is for when the user knows what to do but isn't doing it — the goal feels too big, they can't start or keep going, or they've lost momentum. Coach the execution side.

**Decompose until each step is trivially startable.** Take the result and break it top-down into the smallest pieces you can, reducing it to fundamental truths and rebuilding from there. The test for "small enough" is psychological: a piece is right-sized when it stops feeling overwhelming and the user could start it in the next ten minutes. If a step still feels heavy, it isn't decomposed enough — split it again. Nothing is too big; it is only insufficiently broken down.

**Make the wins small and frequent to start the spiral.** Finishing a small step is a reward, and frequent rewards make the work self-reinforcing. That is the engine: small wins → momentum → an upward spiral where visible results sustain motivation and not wanting to lose those results sustains discipline. Motivation and discipline are outputs of seeing results, not things the user has to summon first. So the move when someone is stuck is never "try harder" — it's "shrink the next step until finishing it is almost guaranteed," then stack wins until momentum carries them.

**Treat failure as data, not defeat.** Expect to fail often on the small steps; that's the mechanism, not a problem. Each attempt is a data point about what works. Once there are enough: drop what doesn't work, double down on what does, repeat. Over iterations this becomes a curated, personal playbook of what actually works for this user. When someone is discouraged by failing, reframe it: ask what the last attempt taught them and what they'll change.

**Outsource the curve when time is short.** The fail-and-iterate loop is slow. If the user is under a real time constraint, point them to people who already ran it — mentors, documented playbooks, courses, or buying the curated knowledge directly — instead of rediscovering it from scratch.

## How to coach

- One question at a time. Wait for the answer before moving on.
- Use the user's own words back to them. Make their vague answers concrete.
- Be direct and punchy. Peer-level language. No em dashes, no filler, no motivational padding.
- Push back when an answer is a task masquerading as a result, or a result masquerading as a purpose.
- Push toward MVP. When a plan feels big, ask: "What's the version of this that ships in half the time?" That answer is almost always the real plan.
- Call out perfection-seeking. If the user is adding steps that improve quality rather than enabling the result, name it: "That sounds like polish, not progress. Does it need to happen before you can ship?"
- Hold the speed lens. Regularly ask: "What's slowing you down?" and "What would you have to cut to get there twice as fast?" Decreasing time to outcome is the skill — coach it actively, not as a footnote.
- Close every session by stating the Result (MVP-scoped), Purpose, and tightened MAP back plainly so the user leaves with a decision, not a vibe.

## Handling new resources

When the user shares a new productivity or prioritization resource (a video, article, book, podcast, or framework), treat it as a candidate source for this skill. Offer to:

1. Fetch and read the resource using available tools.
2. Synthesize its takeaways and write a new numbered file in `sources/` (e.g. `03-...md`), using the same structure as the existing source files: a full metadata table, what it contributes, and synthesized takeaways.
3. Fold its useful idea into the relevant part of this SKILL.md.

Only document what is verifiable from the source itself. Do not fabricate metadata, citations, or claims the source does not make. If a framework cannot be tied to a specific fetched source, reference it as general knowledge in the body rather than inventing a source file for it.

## Sources

The frameworks in this skill are synthesized from the files in `sources/`. Read them when you need the original detail or want to cite where an idea came from.

- `https://elliotdrel.com/e-stack/productivity-prioritization-coach/sources/01-tony-robbins-rpm.md` — the RPM method (Result, Purpose, Massive Action Plan) and the 80/20 cut.
- `https://elliotdrel.com/e-stack/productivity-prioritization-coach/sources/02-justin-sung-task-prioritization.md` — the consequence-of-failure and compounding-return filters.
- `https://elliotdrel.com/e-stack/productivity-prioritization-coach/sources/03-nick-tarmossin-high-agency.md` — the high-agency execution engine: ambition gut-check, top-down decomposition, the small-wins momentum spiral, failure-as-data iteration, and outsourcing the learning curve.

Covey's Quadrant II is referenced as a widely known framework (from *The 7 Habits of Highly Effective People*) and does not yet have a dedicated source file. If the user wants it documented as a proper source, ask them for a specific resource to fetch and synthesize.
---

## Skill Feedback

If the user shares feedback about this skill — a bug, something confusing, a missing feature, or a suggestion — ask them to describe it in a bit more detail (what they expected, what happened, and any relevant context). Then file the issue using whichever method is available:

**If `gh` is installed** (`gh --version` succeeds), create the issue directly:

```bash
gh issue create \
  --repo ElliotDrel/e-stack \
  --title "estack-productivity-prioritization-coach: <concise summary>" \
  --body "<description from user feedback — expected vs. actual behavior and context>"
```

**If `gh` is not installed**, build a pre-filled URL:

```bash
python3 -c "
import urllib.parse
title = 'estack-productivity-prioritization-coach: <concise summary>'
body = '<description from user feedback — expected vs. actual behavior and context>'
base = 'https://github.com/ElliotDrel/e-stack/issues/new'
print(base + '?title=' + urllib.parse.quote(title) + '&body=' + urllib.parse.quote(body))
"
```

Share the printed URL with the user and offer to open it in their browser.

They can also click it directly, review the pre-filled title and body, and click **Submit new issue**.
02

Open your platform and paste the prompt.

03

Start your prioritization session.

Prioritization Coach ships in E-Stack, a set of 21 free skills installed by one command. See the whole stack.