# Effort Lifecycle

> This skill should be used when the user asks "what is an effort", "effort phases", "how do efforts work", "effort vs slice", or needs to understand the effort lifecycle. Covers the five phases: initialize, story capture, requirements, slice identification, and slice spawning.

- Skill: `flox/effort-lifecycle` (Agent Skill)
- Install (CLI): `npx skillmds@latest add flox/effort-lifecycle`
- Raw SKILL.md: https://api.skillmd.com/api/skills/flox/effort-lifecycle/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: flox (https://skillmd.com/u/flox)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/flox/effort-lifecycle

---


# Effort Lifecycle

Overview of Forge effort lifecycle. Efforts are the **discovery
phase** — exploring problem spaces, gathering requirements, and
identifying slice candidates before delivery work begins.

## What is an Effort?

**Effort:** Discovery and exploration work for a problem space.
**Output:** Requirements, user stories, and identified slice
candidates.
**Duration:** Weeks to months (ongoing discovery).
**Location:** `.forge-context/efforts/YYYYMM-{slug}/`

**Example efforts:**
- Explore user authentication options
- Investigate cloud deployment strategies
- Research API versioning approaches

## Effort vs Slice

| Aspect | Effort | Slice |
|--------|--------|-------|
| **Purpose** | Discover + explore | Design + deliver |
| **Output** | Stories, requirements, candidates | Working software |
| **Timeline** | Ongoing (weeks/months) | Time-boxed (days/weeks) |
| **Scope** | Broad problem space | Focused deliverable |
| **State** | Living document | Complete when shipped |

**Flow:** Effort → identifies candidates → spawns Slices →
delivers features

## Effort Phases

### Phase 1: Initialize Effort

**Command:** `/forge:explore init`

**Actions:**
- Create effort directory structure
- Write initial problem framing
- Set up README, effort.md, slices.md, decisions.md

**Output:**
- `.forge-context/efforts/YYYYMM-{slug}/` created
- effort.md with problem context
- slices.md (empty, ready for candidates)

### Phase 2: Story Capture

**Command:** `/forge:explore stories`

**Actions:**
- Capture user stories from stakeholders
- Document user needs and pain points

**Format:**
```markdown
### ST-001: {Story Title}

**As a** {persona}
**I want** {capability}
**So that** {benefit}

**Acceptance Criteria:**
- {criterion 1}
- {criterion 2}
```

### Phase 3: Requirements Gathering

**Command:** `/forge:explore requirements`

**Actions:**
- Extract requirements from stories
- Identify technical constraints
- Map affected components and area owners

**Format:**
```markdown
### REQ-001: {Requirement Title}

**Source:** ST-001, ST-003
**Priority:** High / Medium / Low
**Components:** {list}
```

### Phase 4: Slice Identification

**Command:** `/forge:explore slices`

**Actions:**
- Group related stories/requirements
- Identify shippable increments
- Create slice candidates

**Format:**
```markdown
### SL-001: {Slice Title}

**Stories:** ST-001, ST-002
**Requirements:** REQ-001, REQ-003
**Scope:** {Brief description of deliverable}
**Status:** Candidate / Spawned / Complete
```

### Phase 5: Slice Spawning

**Command:** `/forge:work new` (from slice candidate)

**Actions:**
- Create slice directory
- Copy requirements seed
- Initialize slice workflow

**Output:**
- `.forge-context/slices/YYYYMM-{slug}/` created
- Slice enters delivery lifecycle (see `slice-lifecycle` skill)

## Effort File Structure

```
.forge-context/efforts/YYYYMM-{slug}/
  effort.md               # Living discovery document
  slices.md               # Slice candidate tracking
  decisions.md            # ADRs for effort-level decisions
  checklist.md            # Health tracking
  artifacts/              # Supporting materials
    requirements-seed.md  # Initial requirements analysis
```

## When to Create an Effort

**Create effort when:**
- Problem space is large and unclear
- Multiple deliverables needed
- Discovery work required before design
- Customer research or validation needed

**Skip effort, go straight to slice when:**
- Problem is well-understood
- Single deliverable
- Clear requirements already exist
- Small enhancement to existing feature

## Effort Completion

**Effort completes when:**
- All identified slices are spawned or completed
- No more discovery work needed
- Problem space is exhausted

**Note:** Most efforts are **living documents** — discovery
continues as new needs arise. "Complete" is rare.

## Common Patterns

### Pattern 1: Customer-Driven Effort

1. Create customer/user profiles
2. Extract requirements from user needs
3. Identify user workflows
4. Create slice candidates per workflow

### Pattern 2: Technology Exploration Effort

1. Research current state (what exists?)
2. Identify gaps (what's missing?)
3. Capture user stories (what do users need?)
4. Create slice candidates (feature by feature)

### Pattern 3: Infrastructure Effort

1. Document problem (operational pain)
2. Research solutions (automation patterns)
3. Design architecture (high-level)
4. Create slice candidates (component by component)

## Integration with Forge Workflows

### Discovery → Delivery Flow

```
Effort (Discovery)
  ├─ Stories captured
  ├─ Requirements identified
  ├─ Slice candidates defined
  └─> Slice spawned (Delivery)
        ├─ Requirements refined
        ├─ Design created
        ├─ Implementation planned
        └─> Feature shipped
```

### Effort Commands

- `/forge:explore init` — Initialize effort
- `/forge:explore stories` — Capture user stories
- `/forge:explore requirements` — Extract requirements
- `/forge:explore slices` — Identify candidates
- `/forge:explore review-pr` — Create PR for feedback

## Summary

| Phase | Command | Output |
|-------|---------|--------|
| **Initialize** | `/forge:explore init` | effort.md |
| **Stories** | `/forge:explore stories` | ST-NNN stories |
| **Requirements** | `/forge:explore requirements` | REQ-NNN reqs |
| **Slices** | `/forge:explore slices` | SL-NNN candidates |
| **Spawn** | `/forge:work new` | Slice created |

**Key principles:**
- Discovery before delivery
- Living documents (evolve over time)
- Slice candidates (shippable increments)
- Parallel exploration (multiple efforts active)