What is workflow-feature best used for?

For new projects, new or significantly modified features, or major refactors that require a defined, phase-driven process with mandatory QA.

Do I have to complete every phase in the first iteration?

Yes. Follow all phases on the first iteration and ensure QA passes before work is considered done; subsequent iterations may skip non-QA phases if appropriate, but QA must always pass.

How are tests created in this workflow?

Tests derive from requirements and documentation before implementation; they must fail before code is written and serve as an executable spec to verify behavior.

workflow-feature

Scanned

npx machina-cli add skill lklimek/claudius/workflow-feature --openclaw

Files (1)

SKILL.md

3.2 KB

Feature Workflow

Use for new projects, new/fundamentally modified features, major refactoring.

Follow all phases on the first iteration. Don't skip any phase. Decompose phases into smaller tasks when useful. Match agents to phases by their frontmatter descriptions.

Phases

Requirements → business-domain-analyst + ux-designer Personas, domain knowledge, functional/non-functional requirements, user stories, data needs & processing rules, user journey, DX planning, UI mocks. Validate per persona. Iterate.
Architecture → architect + devops-engineer System layers and responsibilities (trace every layer), tool/tech selection, prefer reuse, guide code placement, deployment model, work decomposition into tasks.
TDD: Tests (per task) → qa-engineer + developer-bilby Write tests from requirements and docs before implementation. Verify they fail (no implementation yet). Tests encode expected behavior — they are the executable spec.
Implementation (per task) → developer-bilby Build env → implement until tests pass → self-review → iterate.
QA → qa-engineer + security-engineer + ux-designer + technical-writer + project-reviewer + devops-engineer Docs (end-user/developer/deployment), integration tests, code quality, security, dependency security, UX/DX audit, pass tests/formatter/linter.

Subsequent Iterations

On subsequent iterations you may use a different workflow, skip non-QA phases if appropriate, or request specialist validation — but QA must always be fully executed.

TDD Discipline

Tests are a dedicated workflow phase, not part of implementation.

Tests derive from requirements and documentation, not from implementation. Encode expected behavior from specs, user stories, or docs.
Tests must fail before implementation begins. A test that passes without new code is either wrong or testing the wrong thing.
Failures are verified against docs. When a test fails post-implementation, check the spec — if the test matches documented behavior, the code is wrong. Only adjust a test when the requirement itself changed.

QA Gate

Never conclude work without passing QA.

First iteration: all phases must complete, including full QA.
Iteration cycles: QA may be deferred between iterations, but must pass before work is considered complete.
No task is done until QA passes. Formatting, linting, and test passing are not optional.

Severity & Iteration

Severity levels (via claudius:severity skill): CRITICAL > HIGH > MEDIUM > LOW > INFO. Iterate until no issues above LOW remain.

Severity inflation guard: if a finding reappears across iterations (same meaning, possibly different agent/ID/wording), its severity must not increase. Downgrade to the previous iteration's level.

Code Deduplication

Every workflow must include a deduplication pass — scan for duplicated logic, extract shared helpers, eliminate copy-paste. Do this during Implementation self-review and QA code quality checks.

Source

git clone https://github.com/lklimek/claudius/blob/main/skills/workflow-feature/SKILL.mdView on GitHub

Overview

workflow-feature prescribes a phased workflow for starting new projects, new features, or major refactors. It requires completing Requirements, Architecture, TDD, Implementation, and QA in order on the first iteration with tasks decomposed as needed. Roles are matched to phases using frontmatter descriptions, and a deduplication pass plus a strict QA gate drive quality.

How This Skill Works

Technically, you map each phase to specific roles as described in the frontmatter, create executable tests from requirements before coding, implement until those tests pass, perform self reviews, and then execute QA with documentation updates. A dedicated deduplication pass happens during Implementation and QA to remove duplicated logic and improve code quality.

When to Use It

Launching a brand new project or module with defined personas and user stories.
Adding a major feature that changes data processing or UX.
Carrying out a major refactor affecting multiple system layers.
Performing a security or compliance upgrade with thorough QA and docs.
Iterating on a project where QA must pass before completion.

Quick Start

Step 1: Define Requirements with business-domain-analyst and ux-designer.
Step 2: Plan Architecture and tasks with architect and devops-engineer.
Step 3: Do TDD, implement until tests pass, self-review, then run QA and update docs.

Best Practices

Follow all five phases in order on the first iteration.
Decompose phases into smaller tasks when useful.
Match agents to phases by their frontmatter descriptions.
Write tests during the TDD phase before any implementation.
Include a deduplication pass during Implementation and QA.

Example Use Cases

New onboarding module built from requirements to QA.
Core feature overhaul that changes UX and analytics.
Significant service refactor across API, data models, and deployment.
Security/compliance upgrade with full QA and docs.
Tech-stack migration with tests, linting, and docs across iterations.

Frequently Asked Questions

Add this skill to your agents