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

feature-implementation skill

safe

This skill guides feature implementation with a structured workflow, clarifies requirements, plans changes, and validates through tests.

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

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

Files (2)

SKILL.md

1.2 KB

---
name: feature-implementation
description: Use when implementing a feature or multi-file code change - provides structured implementation flow with persona selection, validation, and testing guidance.
---

# Feature Implementation

## Overview
Guide feature implementation with clear steps: analyze requirements, plan approach, implement safely, and validate with tests.

## When to Use
- Implementing a feature, component, service, or API
- Coordinating multi-domain changes (UI + API + tests)
- Adding tests alongside implementation

Avoid when:
- The task is a trivial one-line change
- You only need a plan (use implementation-workflow)

## Quick Reference

| Task | Load reference |
| --- | --- |
| Implementation workflow | `skills/feature-implementation/references/implement.md` |

## Workflow
1. Clarify requirements and constraints.
2. Load the implementation reference.
3. Implement changes with appropriate personas/tools.
4. Add or update tests.
5. Validate with builds/tests.

## Output
- Implementation summary
- Validation results and remaining risks

## Common Mistakes
- Implementing without tests or validation
- Skipping integration considerations
- Mixing planning and implementation without agreement

Overview

This skill guides a developer through implementing a feature or multi-file code change with a structured, practical workflow. It emphasizes persona selection, safe implementation steps, and validation so changes are delivered with tests and reduced integration risk. The output is a clear summary of what was implemented, test results, and any remaining risks.

How this skill works

You start by clarifying requirements and constraints, then load an implementation reference to align on style and expectations. Select appropriate personas or tools (e.g., feature developer, reviewer, QA) and follow a step-by-step implementation flow across files and services. Add or update tests, run builds, and report validation results and residual risks.

When to use it

Implementing a new feature, endpoint, component, or service that spans multiple files
Coordinating changes across UI, API, and backend with associated tests
Adding or updating unit, integration, or end-to-end tests along with code changes
Performing non-trivial refactors that require validation across modules
Delivering a complete code change that must be validated by CI and local testing

Best practices

Start by clarifying acceptance criteria and any constraints before touching code
Choose personas for each phase: implementer, reviewer, and tester to reduce blind spots
Work iteratively: small, test-covered commits that build and run locally
Update or add tests immediately and run CI locally to catch integration issues
Document implementation decisions and remaining risks in the summary output

Example use cases

Adding a new API endpoint plus client UI and integration tests
Implementing a recommendation-engine feature that requires model and API changes
Coordinating a cross-repo change where backend and CLI updates are required
Refactoring a core module while preserving public behavior and adding test coverage
Fixing a bug that needs a targeted change plus regression tests

FAQ

What personas should I pick for implementation?

Choose at least an implementer to write code, a reviewer to check design and safety, and a tester to validate behavior and write tests.

What if the change is trivial?

For one-line or trivial fixes, use a minimal approach and avoid the full workflow; skip persona orchestration but still add a test when possible.