Idea decomposition

Skill wdm0006/idealog-skills/skills/idea-decomposition

Breaks a large or complex idea into smaller, actionable sub-ideas, each with their own first steps and tags. Creates the sub-ideas in idea.log and links them back to the parent. Use when an idea feels too big to start.From its SKILL.md

Install

npx -y skills add wdm0006/idealog-skills --skill idea-decomposition

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

4.1 KB, as published. Nobody here has run it

Decompose an Idea into Actionable Pieces

Works with idea.log. Get it on the App Store.

When to Use

An idea feels too big or vague to start working on
You want to turn a project-sized idea into a series of concrete tasks
An idea has been sitting in "Pending" (see the shared status reference) because the scope is intimidating
You want to make incremental progress on a large concept

How It Works

User specifies which idea to decompose (by name or search term)
Find the idea with search_ideas and fetch details with get_idea
Analyze the idea's scope, description, comments, and tags
Break it into 3-7 smaller, independent sub-ideas
Confirm the decomposition with the user
Create each sub-idea with create_idea, inheriting relevant tags and adding a reference to the parent
Update the parent idea with update_idea to note it's been decomposed
Add a comment to the parent with add_comment listing the sub-ideas

Decomposition Principles

Good Sub-Ideas

Independent — Each can be worked on without completing the others first
Specific — Clear enough that you know when it's done
Small — Completable in one focused session (1-4 hours)
Has a first step — Every sub-idea gets a concrete first action

Decomposition Patterns

Parent Idea Type	Decomposition Strategy
App or tool	Split by feature or component (auth, UI, data layer, CLI)
Blog post or content	Split by section or research task
Learning goal	Split by topic or milestone
Refactor	Split by module or system boundary
Experiment	Split into hypothesis, setup, execution, analysis

Example

Input:

Break down my "personal finance dashboard" idea

Actions:

1. Found idea: "Build a personal finance dashboard"
   Tags: app, web, multi-week
   First step: none
   Comments: "Should pull from bank APIs and show spending trends"

2. Proposed decomposition:

   a) "Finance dashboard: Research bank/financial data APIs"
      First step: "List 3 aggregation APIs (Plaid, Yodlee, MX) and compare pricing"
      Tags: app, web, research

   b) "Finance dashboard: Design data model for transactions"
      First step: "Draft schema for accounts, transactions, and categories"
      Tags: app, web, data

   c) "Finance dashboard: Build transaction import pipeline"
      First step: "Set up a Plaid sandbox account and fetch sample transactions"
      Tags: app, web, api

   d) "Finance dashboard: Create spending category visualization"
      First step: "Pick a charting library and render a sample pie chart with mock data"
      Tags: app, web, design

   e) "Finance dashboard: Build monthly trend view"
      First step: "Aggregate sample transactions by month and render a line chart"
      Tags: app, web, design

3. User confirmed. Created 5 sub-ideas.
4. Updated parent idea: "Decomposed into 5 sub-ideas — see comments"
5. Added comment to parent listing all sub-ideas with their first steps

Checklist

Idea Decomposition:
- [ ] Found and reviewed the target idea
- [ ] Analyzed scope and identified natural boundaries
- [ ] Created 3-7 independent sub-ideas
- [ ] Each sub-idea has a first step and tags
- [ ] Confirmed decomposition with user
- [ ] Updated parent idea with decomposition note
- [ ] Added comment linking to all sub-ideas