home / skills / nickcrew / claude-cortex / workflow-feature

workflow-feature skill

Q: What outputs does the workflow produce?

Architecture diagrams, component lists, API specs, task lists with estimates, tests, docs, changelog entries, migration scripts, and a deployment/rollback checklist.

Q: How does it enforce quality gates?

The workflow requires code review, security review, defined success criteria (tests passing, performance and security checks), and a final review command before marking complete.

safe

/skills/workflow-feature

This skill guides teams through feature development from design to deployment, outlining steps, agents, and documents to ensure quality.

npx playbooks add skill nickcrew/claude-cortex --skill workflow-feature

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

Files (1)

SKILL.md

2.6 KB

---
name: workflow-feature
description: Complete feature development workflow from design to deployment. Use when implementing new features or functionality.
---

# Feature Development Workflow

Complete workflow for developing new features from design to deployment.

## Phases

### 1. Architecture Design
**Define:**
- Component structure
- Data models
- API contracts
- Integration points
- Dependencies

**Output:** Architecture diagram, component list, API specs

**Agent:** `architect-review` for complex features

### 2. Implementation Planning
**Break down into:**
- Discrete tasks (< 2 hours each)
- Dependencies between tasks
- Parallel workstreams

**Output:** Task list with estimates

### 3. Implementation
**Guidelines:**
- Write tests alongside code (TDD optional but helpful)
- Commit frequently (atomic commits)
- Follow existing patterns in codebase
- Document as you go

**Run parallel workstreams:**
- Core implementation
- Tests
- Documentation

### 4. Code Review
**Checklist:**
- [ ] Code follows project conventions
- [ ] No obvious bugs or edge cases missed
- [ ] Performance acceptable
- [ ] Error handling complete
- [ ] Tests meaningful (not just coverage)

**Agent:** `code-reviewer`

### 5. Security Review
**Check:**
- Input validation
- Auth/authz on new endpoints
- Sensitive data handling
- No secrets in code

**Agent:** `security-auditor` (if auth-related)

### 6. Testing
**Required:**
- Unit tests (80%+ coverage on new code)
- Integration tests for API endpoints
- E2E tests for critical paths

**Agent:** `test-automator` or `debugger`

### 7. Performance Check
**Verify:**
- Response times acceptable
- No memory leaks
- Bundle size impact (frontend)

**Agent:** `performance-engineer` (if perf-sensitive)

### 8. Documentation
**Update:**
- API docs (OpenAPI/Swagger)
- User guide (if user-facing)
- Changelog entry
- README if needed

### 9. Deployment Prep
**Checklist:**
- [ ] Version bumped
- [ ] Changelog updated
- [ ] Migration scripts (if DB changes)
- [ ] Rollback plan documented
- [ ] Feature flags (if gradual rollout)

## Success Criteria
- [ ] All tests pass
- [ ] Security review clean
- [ ] Performance within limits
- [ ] Documentation complete
- [ ] Code reviewed and approved

## Review Gate
```bash
# Run before marking complete
cortex review -c feature
```

## Quick Start Template

```markdown
## Feature: [Name]

### Requirements
- [ ] Requirement 1
- [ ] Requirement 2

### Tasks
- [ ] Task 1
- [ ] Task 2
- [ ] Tests
- [ ] Docs

### API Changes
- `POST /api/v1/resource` - Create resource
- `GET /api/v1/resource/:id` - Get resource

### Rollback Plan
1. Revert commit
2. Run down migration
3. Clear cache
```

Overview

This skill automates a complete feature development workflow from initial architecture to deployment readiness. It guides teams through design, planning, implementation, testing, security, performance checks, documentation, and deployment prep. Use it to standardize feature delivery and reduce missed steps.

How this skill works

The skill inspects feature requirements and produces outputs for each phase: architecture diagrams, task breakdowns, test and documentation checklists, and deployment checklists. It assigns phase-specific agents for architecture review, code review, security, testing, and performance verification, and enforces success criteria before marking a feature complete.

When to use it

Adding a new API endpoint or user-facing functionality
Implementing database schema changes or migrations
Rolling out performance-sensitive or security-sensitive features
Coordinating parallel work across multiple engineers
Preparing a staged or feature-flagged rollout

Best practices

Define components, data models, and API contracts before writing code
Break work into small tasks (<2 hours) with explicit dependencies
Write tests alongside code; aim for meaningful coverage on new code
Commit atomically and follow existing project patterns
Document API changes, user guidance, and rollback plans before deployment
Use feature flags and a rollback plan for gradual rollouts

Example use cases

Design and implement a new POST/GET API surface with OpenAPI docs and integration tests
Add a database-backed feature requiring migrations and a clear rollback path
Ship a user-facing UI change while keeping bundle size and response times within limits
Introduce auth-protected endpoints and run a focused security audit
Coordinate multiple parallel workstreams: core code, tests, and documentation

FAQ

What outputs does the workflow produce?

Architecture diagrams, component lists, API specs, task lists with estimates, tests, docs, changelog entries, migration scripts, and a deployment/rollback checklist.

How does it enforce quality gates?

The workflow requires code review, security review, defined success criteria (tests passing, performance and security checks), and a final review command before marking complete.