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:

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

---
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:

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.