home / skills / yellinzero / aico / aico-frontend-task-breakdown

aico-frontend-task-breakdown skill

/.codex/skills/aico-frontend-task-breakdown

This skill breaks a PM story into ordered frontend tasks following UI development layers, ensuring setup, static UI, dynamic logic, interactions, and tests.

npx playbooks add skill yellinzero/aico --skill aico-frontend-task-breakdown

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.4 KB
---
name: aico-frontend-task-breakdown
description: |
  Break down PM story into frontend tasks following UI DEVELOPMENT order: Setup → Static UI → Dynamic Logic → Interactions → Testing.

  UNIQUE VALUE: Ensures proper dependency order. Tasks are ordered by UI development layers, not random order.

  Use this skill when:
  - Running /frontend.tasks command
  - User asks to "break down story", "create frontend tasks", "split into tasks"
  - Have story at docs/reference/pm/stories/ and need organized task list
  - Need tasks ordered by UI development layers (not random order)
  - Starting frontend work and want organized task list

  Task order is CRITICAL: Setup → Static UI → Dynamic → Interactions → Tests
  Output: ALWAYS write to docs/reference/frontend/tasks/{story-name}.md
---

# Task Breakdown

## Language Configuration

Before generating any content, check `aico.json` in project root for `language` field to determine the output language. If not set, default to English.

## Process

1. **Read story/PRD**: Load from `docs/reference/pm/stories/` or `docs/reference/pm/versions/`
2. **Read design** (if exists): Load from `docs/reference/frontend/designs/`
3. **Identify components**: What UI elements are needed
4. **Identify interactions**: What logic and events are needed
5. **Break into tasks**: Independently testable, single responsibility
6. **Order by dependencies**: Setup → Static UI → Dynamic → Tests
7. **Save output**: ALWAYS write to `docs/reference/frontend/tasks/{story-name}.md`

## Task File Template

```markdown
# [Story Name] - Frontend Tasks

> Project: [project-name]
> Created: YYYY-MM-DD
> Last Updated: YYYY-MM-DD
> Source: docs/reference/pm/stories/[story].md
> Design: docs/reference/frontend/designs/[name].md
> Status: in_progress

## Progress

| Task                         | Status         | Notes |
| ---------------------------- | -------------- | ----- |
| 1. Setup component structure | ✅ completed   |       |
| 2. Implement header section  | 🔄 in_progress |       |
| 3. Implement content section | ⏳ pending     |       |

## Tasks

### Task 1: [Task Name]

**Status**: ⏳ pending
**Goal**: What this task achieves
**Scope**: Files to create/modify
**Acceptance Criteria**:

- [ ] Criterion 1
- [ ] Criterion 2
      **Dependencies**: Task X (if any)
```

## Task Types

| Type        | Examples                                |
| ----------- | --------------------------------------- |
| Setup       | Create component structure, setup state |
| UI          | Implement section/component layout      |
| Logic       | Add form validation, API integration    |
| Interaction | Implement hover, click, animations      |
| Testing     | Unit tests, integration tests           |

## Granularity Rules

- Each task = independently testable
- Each task = single responsibility
- Each task = clear scope (not too big, not too small)

## Ordering Rules

1. Setup tasks first
2. Static UI before dynamic
3. Core functionality before edge cases
4. Tests after implementation

## Key Rules

- ALWAYS include test tasks at the end
- MUST note dependencies between tasks
- ALWAYS save to `docs/reference/frontend/tasks/` directory
- Keep tasks focused - not too big, not too small

## Common Mistakes

- ❌ Tasks too large (full page) → ✅ Break into sections
- ❌ Tasks too small (add one button) → ✅ Group related work
- ❌ Skip dependencies → ✅ Note which tasks depend on others
- ❌ Forget testing → ✅ Always include test tasks

Overview

This skill breaks a product/PM story into ordered frontend tasks following a strict UI development sequence: Setup → Static UI → Dynamic Logic → Interactions → Testing. It enforces dependency-aware ordering so tasks are ready to execute in real development flow and are always saved to docs/reference/frontend/tasks/{story-name}.md. Use it to produce clear, independently testable tasks aligned with designs and PRDs.

How this skill works

The skill reads the story or PRD from docs/reference/pm/stories/ (and designs from docs/reference/frontend/designs/ if present), identifies required components and interactions, and generates tasks that are single-responsibility and independently testable. Tasks are grouped and ordered by layer (Setup, Static UI, Dynamic Logic, Interactions, Tests) and include dependencies and acceptance criteria. The output file is written to docs/reference/frontend/tasks/{story-name}.md using a consistent template.

When to use it

  • When running the /frontend.tasks command
  • When asked to "break down story", "create frontend tasks", or "split into tasks"
  • When a story exists in docs/reference/pm/stories/ and you need an organized task list
  • When starting frontend work and you want tasks ordered by UI development layers
  • When you need tasks that note dependencies and include test tasks at the end

Best practices

  • Always start with Setup tasks that create component structure and state wiring
  • Break UI into sections/components; keep tasks single-responsibility and independently testable
  • Order tasks by dependency: Setup → Static UI → Dynamic Logic → Interactions → Tests
  • Include explicit Dependencies and Acceptance Criteria for each task
  • Group small related items to avoid tasks that are too tiny; split large pages into section tasks
  • Always include test tasks last (unit/integration/e2e) covering core and edge cases

Example use cases

  • Convert a PM story for a new dashboard page into ordered frontend tasks, starting with scaffolding components
  • Take a feature PRD and generate tasks that separate static layout from API integration and interactive behaviors
  • Prepare a checklist for a sprint by producing independent tasks with clear acceptance criteria and dependencies
  • Create test tasks after implementation tasks to ensure coverage is planned and not forgotten
  • Generate a tasks file when a designer adds a new design to docs/reference/frontend/designs/ to align implementation

FAQ

Where is the generated task file saved?

Always to docs/reference/frontend/tasks/{story-name}.md using the task file template.

What ordering must tasks follow?

Tasks must follow Setup → Static UI → Dynamic Logic → Interactions → Testing to respect development dependencies.