# Yellinzero Aico Aico Backend Plan

> Plan

- Skill: `tomevault-io/yellinzero-aico-aico-backend-plan` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add tomevault-io/yellinzero-aico-aico-backend-plan`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/yellinzero-aico-aico-backend-plan/raw
- Safety review: pending (external: skill-scanner PASS, skillspector CAUTION)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tomevault-io (https://skillmd.com/u/tomevault-io)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tomevault-io/yellinzero-aico-aico-backend-plan

---


# Plan

## ⚠️ CRITICAL RULES - READ FIRST

1. **DETECT MODE**: Determine if input is an existing task reference or a new requirement description
   - If input looks like `story-user-api Task 1` or `standalone-fix-auth Task 2`: **MODE A**
   - If input is a new requirement (e.g., "Add user authentication"): **MODE B**

2. **MODE A - Enhance Existing Task**:
   - Read the task file from `docs/reference/backend/tasks/`
   - User must specify task number (e.g., "Task 1", "Task 2")
   - Add or update the "Implementation Steps" section for that specific task
   - Keep all other sections intact
   - Save back to the same file

3. **MODE B - Create Standalone Task File**:
   - Analyze the requirement - is it simple (1 task) or complex (multiple tasks)?
   - If complex, break into multiple tasks (like task-breakdown does)
   - Use filename: `standalone-{requirement-name}.md` (kebab-case)
   - Save to `docs/reference/backend/tasks/`
   - File format: same as story-based (multiple task sections)

4. **READ CONSTRAINTS FIRST**:
   - Must read `docs/reference/backend/constraints.md` for tech stack

## 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.

## MODE A: Enhance Existing Task

### Process

1. **Read task file**: Get task details from `docs/reference/backend/tasks/{task-file}.md`
2. **Read constraints**: Load `docs/reference/backend/constraints.md`
3. **Break into atomic steps**:
   - Start with file creation/setup
   - One section/feature per step
   - Include verification for each step
   - Do NOT include commit step (that happens during execution)
4. **Keep steps atomic**: One action per step
5. **Update task file**: Add/replace "Implementation Steps" section
6. **Present summary**: Show file location and what was added

### Example

```bash
# Input: User runs /backend.plan story-user-api Task 1

# Output:
✓ Read task: docs/reference/backend/tasks/story-user-api.md
✓ Added 4 implementation steps to Task 1

Steps added:
1. Define data types and interfaces
2. Create database schema
3. Implement repository layer
4. Add unit tests

Task ready for implementation. Use aico-backend-implement to execute.
```

## MODE B: Create Standalone Task

### Process

1. **Ask user for details**:
   - Task type: feature | bugfix | improvement
   - Confirm task name (auto-generate from description)

2. **Read constraints**:
   - Read technical constraints
   - If user mentions a component, check existing code

3. **Generate complete task file**:
   - All metadata (type, source, created, status)
   - Description
   - Context
   - Acceptance Criteria
   - Scope
   - Implementation Steps (detailed, atomic)
   - Notes

4. **Save task file**: Write to `docs/reference/backend/tasks/standalone-{task-name}.md`

5. **Present summary**: Show created file and next steps

### Example

```bash
# Input: User runs /backend.plan "Fix user authentication endpoint"

# Interactive:
# Type: [feature | bugfix | improvement] → bugfix
# Task name: fix-user-auth-endpoint (auto-generated, confirm?)

# Output:
✓ Created standalone task: standalone-fix-user-auth-endpoint.md

Task includes:
- Description and context
- 2 acceptance criteria
- 3 implementation steps
- Test verification

Next: Use aico-backend-implement to execute this task
```

## Implementation Steps Format

Both modes use the same step format:

````markdown
## Implementation Steps

### Step 1: [Action]

**Files**:

- Create: `src/services/[Name].ts`
- Modify: `src/controllers/[Controller].ts:L10-L20`

**Action**:
[Exact code or action to take]

**Verify**:

```bash
[verification command]
```
````

Expected: [expected output]

---

### Step 2: [Next Action]

...

````

## Step Granularity

Each step = ONE atomic action:

| Good Steps | Bad Steps |
|------------|-----------|
| Create service file with imports | Create service with all methods |
| Add service skeleton (empty methods) | Implement entire service |
| Implement single endpoint | Implement all endpoints |
| Write one test case | Write all tests |

## Step Types

### Setup Step
```markdown
**Files**: Create: `src/services/user.service.ts`
**Action**: Create file with basic structure
**Verify**: `npx tsc --noEmit` → No errors
````

### Implementation Step

```markdown
**Files**: Modify: `src/services/user.service.ts:L8-L10`
**Action**: Implement user creation method
**Verify**: `npm test` → Service tests pass
```

### Test Step

```markdown
**Files**: Create: `src/services/__tests__/user.service.test.ts`
**Action**: Write unit test for user creation
**Verify**: `npm test user.service` → 1 test passed
```

## Standalone Task File Template

For MODE B, see [Task File Template](../task-breakdown/references/task-file-template.md) for complete structure.

Use the same format as story-based tasks, just with:

- Filename: `standalone-{requirement-name}.md`
- Header: `# Standalone Tasks: [Requirement Name]`
- No `> **Story**: ...` line

**Note**: For simple requirements, file may contain only 1 task. For complex requirements, break into multiple tasks.

## Key Rules

- ALWAYS include verification command for each step
- MUST keep steps to 2-5 minutes of work
- MUST save to docs/reference/backend/tasks/ directory
- NEVER combine multiple actions into one step
- Do NOT include commit step in plan (commits happen during execution)
- MODE A: Preserve all existing content, only add/update steps
- MODE B: Generate complete, self-contained task file

## Common Mistakes

- ❌ Steps too large → ✅ One action per step
- ❌ Skip verification → ✅ Every step has verify command
- ❌ Vague actions → ✅ Include exact code
- ❌ Not saving to file → ✅ Always save task file
- ❌ Including commit in steps → ✅ Commits happen during execution, not planning
- ❌ MODE A: Overwriting existing content → ✅ Only update Implementation Steps section
- ❌ MODE B: Missing metadata → ✅ Include all template sections

---
> Converted and distributed by [TomeVault](https://tomevault.io/claim/yellinzero) — claim your Tome and manage your conversions.
<!-- tomevault:4.0:skill_md:2026-04-13 -->

