# Sys Decomposing Goals

> Decomposes a goal into subgoals using top-down derivation formulas. Creates linked goal hierarchy with parent-child relationships. Recursively breaks business goals into system, operational, and tactical goals.

- Skill: `tools-only/sys-decomposing-goals` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds add tools-only/sys-decomposing-goals`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/sys-decomposing-goals/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: Complete terms in LICENSE.txt
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/tools-only/sys-decomposing-goals

---


# Goal Decomposing

Break a single goal into a hierarchy of actionable subgoals.

## Responsibility

Take ONE goal and decompose it into subgoals using derivation formulas. Creates multiple goal files with parent-child links.

## Quick Start

1. Read parent goal from `strategy/goals/active/{goal-dir}/goal.md`
2. Determine decomposition pattern based on category
3. Apply derivation formulas to create subgoals
4. Write subgoal files as `{n}.{name}.md` in the parent goal directory
5. Update parent `goal.md` with child links

## Decomposition Hierarchy

```
Level 1: Business Goal (leadership)
    │    "Achieve $10M ARR"
    │    Time horizon: Annual
    │
    ▼
Level 2: System Goal (RevOps)
    │    "Generate $40M pipeline"
    │    Time horizon: Quarterly
    │
    ▼
Level 3: Operational Goal (Team Leads)
    │    "Book 400 qualified meetings"
    │    Time horizon: Monthly
    │
    ▼
Level 4: Tactical Goal (Individual)
         "Complete 100 outreach touches/day"
         Time horizon: Weekly/Daily
```

## Decomposition Patterns

### Revenue Goal Decomposition

```
Revenue Target ($X ARR)
    │
    ├── Pipeline Target = Revenue / Win Rate
    │       │
    │       ├── Opportunities = Pipeline / Avg Deal Size
    │       │
    │       └── Meetings = Opportunities / Opp Rate
    │               │
    │               └── Outreach = Meetings / Meeting Rate
    │
    ├── Expansion Target = Existing ARR × Expansion Rate
    │       │
    │       └── Expansion Meetings = Target / Avg Expansion Deal
    │
    └── Retention Target = 100% - Churn Rate
            │
            └── At-Risk Interventions = Churn Risk Accounts × Save Rate
```

### Activity Goal Decomposition

```
Meeting Target (X meetings)
    │
    ├── Outbound Meetings = Total × Outbound Ratio
    │       │
    │       └── Outbound Touches = Meetings / Meeting Rate
    │
    └── Inbound Meetings = Total × Inbound Ratio
            │
            └── MQL Target = Meetings / MQL-to-Meeting Rate
                    │
                    └── Traffic Target = MQLs / Conversion Rate
```

### Content Goal Decomposition

```
Content Lead Target (X leads)
    │
    ├── Blog Leads = Total × Blog Attribution %
    │       │
    │       └── Blog Posts = Leads / Leads-per-Post
    │
    ├── Gated Content Leads = Total × Gated %
    │       │
    │       └── Ebooks/Guides = Leads / Leads-per-Asset
    │
    └── Traffic Target = Total / Conversion Rate
            │
            └── SEO Keywords = Traffic / Avg Traffic-per-Keyword
```

## Derivation Formulas

### Revenue Formulas

| From | To | Formula | Defaults |
|------|----|---------|---------| 
| Revenue | Pipeline | `revenue / win_rate` | win_rate: 0.25 |
| Pipeline | Opportunities | `pipeline / avg_deal` | avg_deal: $50K |
| Opportunities | Meetings | `opps / opp_rate` | opp_rate: 0.30 |
| Meetings | Outreach | `meetings / meeting_rate` | meeting_rate: 0.02 |
| Revenue | Expansion | `existing_arr × expansion_rate` | expansion_rate: 0.25 |
| Revenue | New Logo | `(target - existing × nrr) / arpu` | nrr: 1.0 |

### Activity Formulas

| From | To | Formula | Defaults |
|------|----|---------|----------|
| Meetings | MQLs | `meetings / mql_meeting_rate` | rate: 0.15 |
| MQLs | Traffic | `mqls / conversion_rate` | rate: 0.025 |
| Outreach | Emails | `outreach × email_ratio` | ratio: 0.60 |
| Outreach | Calls | `outreach × call_ratio` | ratio: 0.25 |
| Outreach | LinkedIn | `outreach × linkedin_ratio` | ratio: 0.15 |

### Efficiency Formulas

| From | To | Formula | Defaults |
|------|----|---------|----------|
| Win Rate | Stage Rates | `win_rate^(1/stages)` | stages: 4 |
| Cycle Time | Stage Times | `cycle / stages` | stages: 4 |
| CAC | Channel CAC | `cac × channel_weight` | by channel |

## Process

### Step 1: Read Parent Goal

```
Read: strategy/goals/active/{goal-dir}/goal.md
Extract:
  - goal_id (matches directory name, e.g. ea-revenue-q1)
  - category (determines pattern)
  - target_value, target_unit
  - period_start, period_end
  - baseline_value
  - assumptions
```

### Step 2: Determine Decomposition Pattern

```
if category == "revenue":
    if target > $1M:
        pattern = full_revenue_cascade
    else:
        pattern = simple_revenue_cascade
        
if category == "activity":
    pattern = activity_cascade
    
if category == "content":
    pattern = content_cascade
    
if category == "efficiency":
    pattern = efficiency_decomposition
    
if category == "retention":
    pattern = retention_decomposition
```

### Step 3: Apply Formulas

For each subgoal in pattern:
1. Calculate target using formula
2. Inherit period from parent (or subdivide)
3. Inherit constraints proportionally
4. Set parent_goal link
5. Generate goal_id

### Step 4: Write Subgoal Files

Location: Numbered files inside the parent goal directory.

```
strategy/goals/active/{goal-dir}/{n}.{name}.md
```

- `{n}` — sequential number (1, 2, 3...)
- `{name}` — short kebab-case metric name

Subgoal ID format: `{goal-dir}/{n}.{name}`

Examples:
- `ea-revenue-q1/1.launch-readiness`
- `ea-revenue-q1/2.feb-sales`
- `distribution-q1/1.github-organic`

### Step 5: Update Parent

Add child_goals list to parent `goal.md` frontmatter using subgoal IDs:

```yaml
child_goals:
  - ea-revenue-q1/1.launch-readiness
  - ea-revenue-q1/2.feb-sales
  - ea-revenue-q1/3.mar-sales
```

## Output Structure

### Directory Layout

Subgoals are numbered files inside the parent goal directory:

```
strategy/goals/active/{goal-dir}/
├── goal.md              # Parent goal (created by sys-defining-goals)
├── 1.{name}.md          # First subgoal
├── 2.{name}.md          # Second subgoal
└── 3.{name}.md          # Third subgoal
```

### Subgoal File Format

```markdown
---
goal_id: {goal-dir}/{n}.{name}
name: {descriptive name}
category: {inherited or derived}
target_value: {calculated}
target_unit: {inherited or derived}
target_direction: {inherited}
period_start: {inherited or subdivided}
period_end: {inherited or subdivided}
period_type: {inherited or derived}
baseline_value: {calculated or inherited}
baseline_source: derived_from_parent
baseline_date: {same as parent}
parent_goal: {goal-dir}
child_goals: []
thread: null
derivation_formula: {formula used}
derivation_assumptions: [{from parent + new}]
ownership_accountable: {derived from level}
ownership_contributors: []
constraints_budget: {proportional allocation}
constraints_headcount: {proportional allocation}
constraints_capacity: {inherited}
confidence_score: {parent × formula_confidence}
status: active
created: {today}
---

# {Subgoal Name}

## Target

{target_value} {unit} by {period_end}

## Derivation

**Parent Goal:** {goal-dir}/goal.md
**Formula:** {formula_description}

### Calculation

```
{parent_metric}: {parent_value}
{rate_name}: {rate_value}
Result: {parent_value} {operator} {rate_value} = {target_value}
```

## Current State

Baseline derived from parent goal derivation.

## Milestones

| Date | Target | Status |
|------|--------|--------|
| {date_1} | {value_1} | pending |
| {date_2} | {value_2} | pending |

## Dependencies

- **Requires:** {goal-dir}
- **Enables:** {child_goals if any}

## Constraints

Allocated from parent:
- **Budget:** {proportional_amount}
- **Headcount:** {proportional_count}
```

## Recursive Decomposition

For deep hierarchies, apply decomposition recursively:

```
1. Decompose business goal → system goals
2. For each system goal with target > threshold:
   └── Decompose → operational goals
3. For each operational goal with target > threshold:
   └── Decompose → tactical goals
4. Stop when:
   └── Target small enough for single owner
   └── Period is weekly or shorter
   └── No further decomposition formula exists
```

### Decomposition Thresholds

| Category | Level | Continue If |
|----------|-------|-------------|
| Revenue | System | target > $500K |
| Revenue | Operational | target > $100K |
| Activity | Operational | count > 100 |
| Activity | Tactical | count > 20/day |
| Content | Operational | pieces > 10 |

## Constraint Allocation

When parent has constraints, distribute to children:

### Budget Allocation

```
Method 1: Proportional to target
  child_budget = parent_budget × (child_target / total_child_targets)

Method 2: By category weights
  outbound_weight: 0.40
  inbound_weight: 0.35
  content_weight: 0.25
  
Method 3: Fixed allocation
  Some subgoals may have explicit budget assignments
```

### Headcount Allocation

```
If parent.headcount defined:
  - Outreach goals: AE/SDR count
  - Content goals: Writer count
  - Ops goals: Ops count
  
Calculate capacity per person:
  touches_per_sdr = 100/day
  posts_per_writer = 4/month
```

## Workflow

```
1. READ parent goal
   └── Parse frontmatter and body
   └── Extract target, category, period, constraints

2. DETERMINE decomposition pattern
   └── Match category to pattern
   └── Check thresholds for depth

3. CALCULATE subgoals
   └── Apply formulas for each level
   └── Validate against capacity constraints

4. WRITE subgoal files
   └── For each subgoal:
       └── Generate numbered filename: {n}.{name}.md
       └── Set goal_id: {goal-dir}/{n}.{name}
       └── Calculate target and milestones
       └── Write to strategy/goals/active/{goal-dir}/

5. UPDATE parent goal.md
   └── Add child_goals array to frontmatter
   └── Use subgoal IDs: [{goal-dir}/{n}.{name}]

6. RETURN subgoal list
   └── [{goal_id, target, relationship}]
```

## Validation

### Consistency Checks

```
1. Sum of child targets should derive parent target
   Example: If revenue needs $4M pipeline at 25% win rate,
   pipeline subgoal should be $4M (not arbitrary)

2. Time periods should align
   Children period ≤ parent period
   Quarterly parent → Monthly children OK
   Monthly parent → Quarterly children NOT OK

3. Constraints should not exceed parent
   sum(child_budgets) ≤ parent_budget
```

### Achievability Checks

```
1. Capacity validation
   If outreach target > team_capacity × days:
     Flag constraint, adjust or note

2. Historical benchmark
   If required rate > best_historical × 1.5:
     Flag stretch, note risk

3. Dependency check
   If child requires other goal not yet defined:
     Note dependency gap
```

## Integration

### Upstream

- `sys-defining-goals`: Provides parent goal to decompose

### Downstream

- `sys-activating-goals`: Creates threads for leaf goals
- `sys-tracking-goals`: Monitors all goals in hierarchy

### With RevOps

- `rop-calibrator`: Provides scoring models for conversion assumptions
- `rop-allocator`: May trigger decomposition for resource planning

## Boundaries

**This skill provides:**
- Hierarchical decomposition of goals
- Formula-based subgoal derivation
- Parent-child linking
- Constraint allocation

**This skill does NOT:**
- Define the initial parent goal (use `sys-defining-goals`)
- Create execution threads (use `sys-activating-goals`)
- Track progress (use `sys-tracking-goals`)
- Override parent constraints

## Example

### Input

Parent goal directory: `strategy/goals/active/arr-q1/goal.md`
- goal_id: `arr-q1`
- Target: $1,000,000 ARR
- Current: $650,000
- Period: Q1 2026
- Win rate assumption: 25%

### Output

```
strategy/goals/active/arr-q1/
├── goal.md                  # Parent (updated with child_goals)
├── 1.pipeline.md            # Target: $1,400,000 (gap $350K / 0.25)
├── 2.opportunities.md       # Target: 28 ($1.4M / $50K)
├── 3.meetings.md            # Target: 93 (28 / 0.30)
└── 4.outreach.md            # Target: 4,650 touches (93 / 0.02)
```

Parent `goal.md` updated with:
```yaml
child_goals: [arr-q1/1.pipeline, arr-q1/2.opportunities, arr-q1/3.meetings, arr-q1/4.outreach]
```

Each subgoal references `parent_goal: arr-q1` in frontmatter.