Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

categorize-task

/categorize-task

Klasyfikuje zadania programistyczne w ośmiofazowej strukturze czystej architektury (Foundational, Models, Services, Data, Rules, State Management, UI, Tests), aby ustalić, do której fazy należy zadanie.

Licencja
MIT
Ostatnia zmiana repozytorium
18.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 18.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Klasyfikuje zadania programistyczne w ośmiofazowej strukturze czystej architektury (Foundational, Models, Services, Data, Rules, State Management, UI, Tests), aby ustalić, do której fazy należy zadanie.

Oryginalny opis (EN)

Reference guide for classifying development tasks into the 8-phase clean architecture structure (Foundational → Models → Services → Data → Rules → State Management → UI → Tests). Use when you need to determine which architectural phase a task belongs to.

Jak działa

  1. Purpose
  2. The 8 Phases
  3. Classification Process
  4. Clean Architecture Principle
  5. Quick Reference Table
  6. Complex Task Classification
  7. Edge Cases
  8. When in Doubt
  9. Usage Example
Sekcje z nagłówków SKILL.md, w oryginale · 263 linii, 1 171 słów
Podgląd SKILL.md
---
name: categorize-task
description: Reference guide for classifying development tasks into the 8-phase clean architecture structure (Foundational → Models → Services → Data → Rules → State Management → UI → Tests). Use when you need to determine which architectural phase a task belongs to.
user-invocable: false
---

# Categorize Task

Classify development tasks into the 8-phase clean architecture structure. This helps organize work into the correct architectural layer.

## Purpose

Provide a reference guide for determining which architectural phase (Foundational → Models → Services → Data → Rules → State Management → UI → Tests) a development task belongs to.

## The 8 Phases

Tasks must be classified into one of these sequential phases:

### Phase 1: Foundational
**Purpose**: Abstract classes, base setup, toolings, utilities, infrastructure

**Belongs here if the task involves**:
- Setting up base infrastructure
- Creating abstract classes or interfaces
- Configuring tooling or build setup
- Dependency injection framework
- Environment configuration
- Shared utilities and helpers
- Project scaffolding

**Examples**:
- "Set up dependency injection container"
- "Create base repository interface"
- "Configure environment variables"
- "Add logging utility"
- "Set up project structure"

---

### Phase 2: Models
**Purpose**: Entities, models, JSON classes, data structures

**Belongs here if the task involves**:
- Defining a data structure
- Creating an entity or model class
- Data serialization/deserialization
- DTOs (Data Transfer Objects)
- Value objects
- Enums and constants

**Examples**:
- "Create User model with fields"
- "Define Product entity"
- "Add OrderStatus enum"
- "Create UserDTO for API responses"
- "Define Address value object"

---

### Phase 3: Services
**Purpose**: APIs, external services, network layer

**Belongs here if the task involves**:
- Calling an external API
- Integrating with a third-party service
- Network communication
- REST/GraphQL clients
- HTTP/networking layer
- API error handling

**Examples**:
- "Implement authentication API client"
- "Create payment service integration"
- "Add REST API endpoints for products"
- "Integrate with Stripe API"
- "Implement GraphQL query client"

---

### Phase 4: Data
**Purpose**: Repositories, DAOs, data access layer, local storage

**Belongs here if the task involves**:
- Accessing local storage
- Implementing a repository
- Data persistence or caching
- Database access objects
- Local storage (SQLite, SharedPreferences, etc.)
- Cache implementations

**Examples**:
- "Implement UserRepository"
- "Create ProductDAO for database access"
- "Add local cache for API responses"
- "Implement SQLite database schema"
- "Create data source abstraction"

---

### Phase 5: Rules
**Purpose**: Use cases, business rules, domain logic

**Belongs here if the task involves**:
- Business logic or validation
- Use case or workflow
- Domain-specific rules
- Business workflows
- Domain event handlers
- Complex validation rules

**Examples**:
- "Implement login use case"
- "Add business validation for orders"
- "Create checkout workflow"
- "Implement password strength validator"
- "Add discount calculation logic"

---

### Phase 6: State Management
**Purpose**: View models, presenters, state handlers, controllers

**Belongs here if the task involves**:
- Managing application state
- View models or presenters
- State transitions
- State management setup (Bloc, Provider, Riverpod, Redux, etc.)
- Controllers
- Reactive state handling

**Examples**:
- "Create LoginViewModel"
- "Implement ProductListBloc"
- "Add state management for cart"
- "Create AuthenticationCubit"
- "Implement Redux store for user data"

---

### Phase 7: UI
**Purpose**: Widgets, components, screens, views, user interface

**Belongs here if the task involves**:
- Screens, pages, or components
- User interface rendering
- User interaction handling
- Navigation setup
- Layouts and styling
- Visual elements

**Examples**:
- "Create login screen"
- "Build product card component"
- "Implement navigation flow"
- "Add loading spinner widget"
- "Create responsive layout for dashboard"

---

### Phase 8: Tests
**Purpose**: Unit tests, integration tests, e2e tests, test utilities, test fixtures

**Belongs here if the task involves**:
- Writing unit tests for business logic or services
- Creating integration tests across layers
- Building end-to-end test scenarios
- Setting up test utilities, mocks, or fixtures
- Configuring test infrastructure (test runners, coverage tools)
- Writing test helpers or shared test data

**Examples**:
- "Write unit tests for login use case"
- "Add integration tests for checkout flow"
- "Create e2e tests for authentication"
- "Set up mock repository for testing"
- "Add test fixtures for product data"

---

## Classification Process

To classify a task, ask these questions in order:

1. **Is it foundation/infrastructure?** → Phase 1
2. **Is it defining data structures?** → Phase 2
3. **Does it call external APIs?** → Phase 3
4. **Does it access local data/storage?** → Phase 4
5. **Is it business logic/rules?** → Phase 5
6. **Does it manage application state?** → Phase 6
7. **Is it user interface?** → Phase 7
8. **Does it write tests or test utilities?** → Phase 8

## Clean Architecture Principle

Remember: Dependencies flow inward
```
Tests → UI → State Management → Rules → Data → Services → Models → Foundational
```

- **Outer layers** depend on **inner layers**
- **Inner layers** never depend on **outer layers**
- Each phase can only depend on phases that come before it

## Quick Reference Table

| If the task creates... | Phase |
|------------------------|-------|
| Abstract base classes, utilities | 1 - Foundational |
| Data models, entities, DTOs | 2 - Models |
| API clients, external integrations | 3 - Services |
| Repositories, DAOs, local storage | 4 - Data |
| Use cases, business rules | 5 - Rules |
| ViewModels, Blocs, state handlers | 6 - State Management |
| Screens, widgets, components | 7 - UI |
| Unit tests, integration tests, e2e tests | 8 - Tests |

## Complex Task Classification

Some tasks may span multiple phases. In these cases:

1. **Break the task down** into sub-tasks for each phase
2. **Create separate tasks** for each phase
3. **Maintain phase order** - implement foundation before UI

**Example**: "Implement user authentication"
- Phase 1: Create base auth interfaces
- Phase 2: Define User and Token models
- Phase 3: Implement auth API client
- Phase 4: Create auth token repository
- Phase 5: Create login/logout use cases
- Phase 6: Build AuthenticationBloc/ViewModel
- Phase 7: Create login/signup screens
- Phase 8: Write unit and integration tests for auth flow

## Edge Cases

**Configuration files**: Phase 1 (Foundational) if infrastructure, Phase 7 (UI) if theme/styling

**Validation**: Phase 5 (Rules) if business validation, Phase 6 (State Management) if form state validation

**Error handling**: Goes with the phase where the error occurs

**Testing**: Always Phase 8 (Tests), regardless of which phase the tested code belongs to

**Documentation**: Same phase as the feature being documented

## When in Doubt

If you're unsure between two phases:
1. Consider the **primary responsibility** of the code
2. Think about **dependencies** - what does this code depend on?
3. Ask: "Where does this fit in the dependency flow?"
4. Choose the **earlier phase** when truly ambiguous (favor inner layers)

## Usage Example

**Task**: "Add user profile picture upload"

**Classification**:
- Primary responsibility: UI interaction (file picker, display)
- Depends on: API service, data storage, business rules
- This is primarily about user interface

**Result**: **Phase 7 (UI)** - but may require supporting tasks in earlier phases:
- Phase 3: API endpoint for upload
- Phase 4: Save profile picture URL locally
- Phase 5: Validate image size/format

Wersje

W bazie nie ma innych skilli o nazwie categorize-task.

Migawka bazy z 13.11.2026 · wersja paczki 95472b84d240 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 95development
    Koordynuje wszystkie zadania programistyczne, dobierając fazy do cech zadania, także przy pozornie prostych zmianach w kodzie.
  • 100php-project-guide
    Przekazuje wiedzę o strukturze projektu PHP, środowisku, standardach, testach PHPUnit i Composerze w pracy agenta.
  • 100repo-understanding-repository-architecture
    Opisuje sześciowarstwową hierarchię zarządzania repozytorium: od wizji przez zasady, konwencje i rozwój, po agentów i przepływy pracy.
  • 100flutter-architecture
    Podaje wzorce architektury aplikacji Flutter: struktura feature-first, clean architecture i zarządzanie stanem (Bloc, Riverpod, Provider), wstrzykiwanie zależności i dobór podejścia.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.