Recommended Task Granularity for Development Plans in OpenAI's Writing-Plans Skill

The writing-plans skill recommends breaking development plans into bite-sized tasks that take 2–5 minutes each, where every step represents a single, concrete action such as writing a failing test, running it, or committing code.

The openai/plugins repository includes a specialized writing-plans skill within its superpowers suite that generates structured implementation plans. According to the source specification, this skill enforces strict task granularity to keep development cycles test-driven and iteration-friendly. By following the 2–5 minute rule, developers maintain clear focus, enable frequent commits, and minimize the scope of individual changes.

The 2–5 Minute Rule for Task Granularity

The writing-plans skill explicitly defines task granularity in plugins/superpowers/skills/writing-plans/SKILL.md. Each step must represent one action that a developer can complete within 2–5 minutes.

This constraint ensures that:

• Cognitive load remains low – developers focus on one specific operation at a time
• Feedback loops stay tight – rapid cycles between writing, testing, and committing
• Scope creep is prevented – no single task encompasses multiple logical operations

The skill documentation states: "Each step is one action (2‑5 minutes)", establishing this as the canonical standard for all generated development plans.

Breaking Down Development Plans into Single Actions

When the writing-plans skill generates a plan, it decomposes work into discrete, executable steps. The recommended pattern follows a test-driven development cycle with explicit granularity:

Write the Failing Test

The first step creates a test that defines the desired behavior before implementation exists. This ensures the test accurately validates the requirement rather than the existing code.

Run and Verify Failure

A separate step executes the test to confirm it fails for the expected reason (typically a NameError or missing function). This validates that the test is actually testing the right thing.

Implement Minimal Code

The implementation step focuses solely on writing the minimum code necessary to make the specific failing test pass. No additional features or refactoring occur at this stage.

Verify and Commit

Final steps run the test suite to confirm the fix works, then commit the changes. This completes the atomic transaction of the feature addition.

Practical Example of Writing-Plans Task Granularity

Below is a typical task generated by the writing-plans skill, illustrating the recommended granularity for adding a helper function:

### Task 1: Add `is_even` helper

**Files:**
- Create: `src/utils/math_helpers.py`
- Test: `tests/utils/test_math_helpers.py`

- [ ] **Step 1: Write the failing test**

```python
def test_is_even():
    assert is_even(2) is True
    assert is_even(3) is False

• Step 2: Run test to verify it fails
  pytest tests/utils/test_math_helpers.py::test_is_even -v → FAIL (function not defined)

• Step 3: Write minimal implementation

def is_even(n):
    return n % 2 == 0

• Step 4: Run test to verify it passes
  pytest tests/utils/test_math_helpers.py::test_is_even -v → PASS

• Step 5: Commit

git add src/utils/math_helpers.py tests/utils/test_math_helpers.py
git commit -m "feat: add is_even helper with tests"

Each bracketed step represents a distinct 2–5 minute action, following the **Bite-Sized Task Granularity** section defined in the skill specification.

## Integration with Subagent-Driven Development

The fine-grained plans produced by **writing-plans** are designed to be consumed by the **subagent-driven-development** skill, located at [`plugins/superpowers/skills/subagent-driven-development/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/subagent-driven-development/SKILL.md). 

This execution sub-skill interprets the granular steps and delegates them to coding agents or developers. The strict 2–5 minute granularity ensures that subagents receive unambiguous, atomic instructions that minimize context switching and reduce the risk of partial implementations. When combined, these skills create a deterministic pipeline from planning to execution where every task boundary is explicitly defined and time-boxed.

## Summary

- **Task duration**: Each step in a writing-plans generated plan should take **2–5 minutes** to complete
- **Single action principle**: Every task must represent **one concrete action**, such as writing a test, running a command, or committing code
- **Source specification**: Defined in [`plugins/superpowers/skills/writing-plans/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/writing-plans/SKILL.md) under the **Bite-Sized Task Granularity** section
- **Test-driven workflow**: The granularity supports TDD cycles with explicit steps for failing tests, implementation, and verification
- **Execution compatibility**: Plans feed into `subagent-driven-development` for automated or manual execution

## Frequently Asked Questions

### Why does the writing-plans skill limit tasks to 2–5 minutes?

The 2–5 minute constraint prevents scope creep and maintains developer focus on single, concrete actions. According to the `openai/plugins` source code, this granularity keeps plans test-driven and iteration-friendly, ensuring that each step produces a verifiable outcome before proceeding to the next action.

### How does task granularity affect the subagent-driven-development skill?

The **subagent-driven-development** skill consumes plans generated by **writing-plans** and delegates them to execution agents. The fine granularity ensures subagents receive atomic, unambiguous instructions that reduce context switching and enable precise progress tracking, as implemented in [`plugins/superpowers/skills/subagent-driven-development/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/subagent-driven-development/SKILL.md).

### Can I combine multiple small steps into a single larger task?

No, the specification explicitly discourages combining steps. The **writing-plans** skill treats each action—writing tests, running them, implementing code, and committing—as separate entries to maintain clear verification points and minimize the risk of undetected errors creeping into the codebase.

### What happens if a task takes longer than 5 minutes?

If a step exceeds 5 minutes, it likely violates the single-action principle and should be decomposed further. The skill recommends splitting complex operations into smaller sub-tasks, such as separating "implement the function" from "write the tests," to maintain the 2–5 minute target and preserve the clarity of the development plan.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}