skills.rest
fercracix33
fercracix33COMMUNITY
Explore all skills by this author →
GitHub

implementer-agent-skill

Generate minimal test-passing implementations for use cases and API routes.

Updated Sep 29, 2025
Search Tags:#typescript#tdd#clean architecture#next.js#api development#use cases#zod
One-click install
npx skills add https://github.com/fercracix33/poli2-clean-architecture --skill implementer-agent-skill
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: implementer-agent-skill
Source: https://github.com/fercracix33/poli2-clean-architecture/tree/main/.claude/skills/implementer-agent-skill
Command: npx skills add https://github.com/fercracix33/poli2-clean-architecture --skill implementer-agent-skill

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires npm, and includes assets (resource) and references (resource) components.

What problem does it solve?

This Skill eliminates the manual, repetitive work of writing use cases and API endpoints, ensuring strict Test-Driven Development (TDD) compliance and adherence to Clean Architecture principles. It guides the implementation process from failing tests (Red phase) to passing tests (Green phase) and refactoring, saving developers significant time and reducing complexity.

Core Features & Use Cases

  • TDD-Driven Implementation: Guides the creation of minimal code to make failing tests pass, following the Red → Green → Refactor cycle.
  • Use Case Development: Implements business logic with Zod validation, authorization checks, and service orchestration.
  • Next.js API Endpoint Creation: Develops thin API controllers with authentication, request parsing, and robust error mapping to HTTP status codes.
  • Architectural Compliance: Ensures strict adherence to Clean Architecture boundaries, separating concerns between layers.
  • Use Case: After a Test Agent delivers a suite of failing tests for a new Task feature, this Skill automatically implements the createTask use case and the POST /api/tasks API endpoint, making all tests pass while maintaining high code quality and architectural integrity.

Quick Start

1. Ensure failing tests exist for your feature.

2. The AI will guide you through implementing use cases and API endpoints.

3. Run tests to confirm success (Green Phase):

npm run test:watch -- src/features/{feature}/use-cases/

Frequently Asked Questions about implementer-agent-skill

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

FAQPage Schema
How do I implement use cases and API endpoints following Test-Driven Development with Clean Architecture?▼

TDD-driven implementation automates generating minimal, test-passing code for use cases and Next.js API routes by guiding you through Red → Green → Refactor cycles. It ensures Zod validation, dependency injection, and architectural separation of concerns while keeping tests immutable and implementation focused.

Can I use this approach with Next.js App Router and TypeScript?▼

Yes. This Skill generates type-safe implementations for Next.js App Router API routes with full TypeScript support, Zod-based request validation, async/await orchestration, and standardized HTTP error mapping, maintaining strict architectural boundaries.

How do I ensure my use cases pass validation and error handling tests automatically?▼

The Skill scaffolds use cases with Zod safeParse validation, authorization checks, and service orchestration, then auto-generates API endpoints that map business logic errors to appropriate HTTP status codes, satisfying all test requirements in a single pass.

What's the fastest way to go from failing tests to production-ready API endpoints?▼

After your test suite defines the contract, this Skill implements minimal code to make tests pass while respecting Clean Architecture layers, reducing manual scaffolding work and enabling rapid red-to-green iterations without quality trade-offs.

Does this Skill require existing failing tests before I start implementing?▼

Yes. The Skill operates within a strict TDD workflow: ensure failing tests exist for your feature first, then it guides implementation through the Red phase to Green phase, making all tests pass while maintaining architectural integrity.

How does this handle dependency injection and service orchestration in use cases?▼

Implementations include dependency-injected services and orchestration patterns that satisfy use-case requirements, integrating authorization, validation, and business logic while preserving testability and Clean Architecture separation between domain, application, and infrastructure layers.

Related Skills

Explore More Software Engineering Skills→
BoraPerusicBoraPerusic

tdd-workflows-tdd-red

Generate failing test templates with edge cases and error paths.

Community
Advanced
DarkMonkDevDarkMonkDev
1

test-environment

Run unit, integration, and end-to-end tests in isolated containers.

Community
Advanced
MolcajeteAIMolcajeteAI
2

zod-validation

Validate API inputs and environment variables using Zod schemas.

Official
Intermediate
bankielewiczbankielewicz

implementing-stories

Automate user story implementation with a strict TDD workflow and architectural constraints.

Community
Advanced