implementation

Automate feature implementation with TDD, tests, and documentation.

25|2|Updated Oct 26, 2025
One-click install
npx skills add https://github.com/matteocervelli/llms --skill implementation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implementation
Source: https://github.com/matteocervelli/llms/tree/main/.claude/skills/implementation
Command: npx skills add https://github.com/matteocervelli/llms --skill implementation

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires pytest, black, mypy, flake8, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill guides developers through a structured implementation process, ensuring features are built with high-quality code, robust tests, and thorough documentation, adhering to project standards and Test-Driven Development (TDD) principles.

Core Features & Use Cases

  • Test-Driven Development (TDD): Systematically follows the Red-Green-Refactor cycle for building reliable, bug-resistant code.
  • Code Quality & Standards: Enforces PEP 8, type hints, Google-style docstrings, and modular design using automated checks (Black, mypy, flake8).
  • Comprehensive Testing: Guides the creation of unit, integration, and end-to-end tests with high coverage targets (80%+), ensuring all code paths are validated.
  • Use Case: After a feature's design is approved, use this skill to systematically implement the code, write tests, and generate documentation, ensuring all quality gates are met before code review and deployment.

Quick Start

Implement the core logic for a new user registration feature, following TDD and generating unit tests for the main service.

Frequently Asked Questions about implementation

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

FAQPage Schema
How do I implement features using test-driven development with Python?

Test-driven development for Python features follows the Red-Green-Refactor cycle: write failing tests first, implement code to pass them, then refactor. This Skill automates that workflow, coordinating tests, code quality checks, and documentation to ensure production-ready features that meet 80%+ coverage targets.

What code quality standards does this implementation process enforce?

The implementation process enforces PEP 8 style, type hints via mypy, Google-style docstrings, and modular design using Black for formatting and flake8 for linting. These automated checks run continuously to maintain consistent code quality across your feature.

Can I use this to write unit, integration, and end-to-end tests together?

Yes. This Skill guides creation of unit, integration, and end-to-end tests as part of the implementation workflow. It coordinates all test types with pytest, ensuring comprehensive coverage and validation of every code path before deployment.

How does this workflow fit into the feature development process?

Use this Skill after your feature design is approved. It systematically implements code, writes tests, and generates documentation while enforcing TDD discipline and quality gates, preparing the feature for code review and deployment.

What happens if my code doesn't meet the quality or coverage requirements?

The automated checks via Black, mypy, flake8, and pytest flag quality or coverage gaps before code review. The workflow enforces standards and test-coverage requirements (80%+), ensuring you address issues during implementation rather than later.

Do I need prior experience with pytest and type hints to use this?

The Skill is designed for developers following TDD and quality standards but provides structure and automation for those newer to pytest, mypy, or type hints. It coordinates these tools to enforce discipline; familiarity with Python is the main prerequisite.