skills.rest
oxie
oxieCOMMUNITY
Explore all skills by this author →
GitHub

implementation-phase

Enforce test-driven development and anti-duplication controls during implementation tasks.

Updated Oct 26, 2025
Search Tags:#code quality#testing#development workflow#refactoring#software development#code reuse#test-driven development
One-click install
npx skills add https://github.com/oxie/portfolio-cms-project --skill implementation-phase-oxie
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: implementation-phase
Source: https://github.com/oxie/portfolio-cms-project/tree/main/.claude/skills/implementation-phase
Command: npx skills add https://github.com/oxie/portfolio-cms-project --skill implementation-phase-oxie

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill guides developers through the /implement phase, ensuring strict Test-Driven Development (TDD), preventing code duplication, and maintaining high quality through continuous testing. It solves the problem of inconsistent code quality, missed tests, and accumulating technical debt.

Core Features & Use Cases

  • TDD Workflow Enforcement: Guides through the RED → GREEN → REFACTOR cycle for every task, ensuring tests are written before implementation.
  • Anti-Duplication Checks: Provides strategies and commands (e.g., grep) to actively search for and prevent redundant code.
  • Continuous Testing: Integrates unit, integration, component, and E2E testing throughout the phase to catch issues early.
  • Use Case: A developer needs to implement a new feature. This skill ensures they write failing tests first, build minimal code to pass, then refactor, all while actively checking for existing reusable patterns and continuously running tests.

Quick Start

Implement the 'StudentProgressService' feature following the TDD workflow, ensuring all tests pass and no code duplication is introduced.

Frequently Asked Questions about implementation-phase

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement test-driven development to ensure code quality?▼

Test-driven development (TDD) enforces writing failing tests before implementation, then building minimal code to pass them, followed by refactoring. This Skill automates the RED-GREEN-REFACTOR cycle across 20-30 implementation tasks, catching defects early and maintaining consistent quality throughout development.

How can I prevent code duplication during implementation?▼

Anti-duplication checks actively search for redundant code patterns using tools like grep to identify existing reusable implementations. This Skill applies these checks throughout the implementation phase, helping you reuse existing patterns and avoid accumulating technical debt.

What's the best way to run continuous testing across unit, integration, and end-to-end tests?▼

Continuous testing integrates unit, integration, component, and E2E test suites throughout implementation, executing tests after each RED-GREEN-REFACTOR cycle. This Skill automates test generation and execution across all levels, catching issues early and ensuring requirements are met.

Can I use TDD for implementing features from specification documents?▼

Yes. This Skill applies TDD workflow to end-to-end implementation tasks derived from specs, updating tasks.md and workflow-state.yaml as you progress through the RED-GREEN-REFACTOR cycle, ensuring all functional requirements are met and no code duplication occurs.

How do I maintain a consistent development workflow while refactoring?▼

The RED-GREEN-REFACTOR workflow enforces consistent phases: write failing tests (RED), implement minimal code (GREEN), then improve design (REFACTOR). This Skill guides this cycle for each task while maintaining continuous testing and anti-duplication checks, preventing quality degradation.

What testing levels should I implement during the development phase?▼

Development phase testing includes unit tests for individual components, integration tests for module interactions, component tests for behavior verification, and end-to-end tests for complete workflows. This Skill orchestrates all four levels throughout implementation to catch issues at each layer.

Related Skills

Explore More Software Engineering Skills→
AcidicSoilAcidicSoil
1

implement-feature

Implement task specifications via TDD Red-Green-Refactor cycles with tests and telemetry.

Community
Advanced
jobayerarmanjobayerarman

session-ready-for-pr

Prepare a development branch for pull request submission with validation and cleanup.

Community
Intermediate
baphledbaphled
1

check-compliance

Run linting, formatting, security scans, and tests before committing code.

Community
Intermediate
summarybotngsummarybotng
2

xp-practices

Guide XP and agile implementation with TDD, CI, and Pair Programming practices.

Official
Advanced