clean-implementation

Translate Kotlin/Java Clean Architecture modules into Python with Pydantic models.

Updated Nov 25, 2025
One-click install
npx skills add https://github.com/NikhilVijayakumar/Yantra --skill clean-implementation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-implementation
Source: https://github.com/NikhilVijayakumar/Yantra/tree/main/.agent/skills/clean-implementation
Command: npx skills add https://github.com/NikhilVijayakumar/Yantra --skill clean-implementation

SYSTEM DOCUMENTATION & REQUIREMENTS

## What problem does it solve? Translates Kotlin/Java Clean Architecture patterns into Python with Pydantic models, strict isolation, and non-interactive config injection to ensure publication-ready codebases.

## Core Features & Use Cases

  • Translates domain, use cases, and interfaces from Kotlin/Java Clean Architecture into Python with Pydantic-based models.
  • Enforces zero-hidden state via constructor injection and Protocol-based dependencies.
  • Provides guidelines for creating builder or factory patterns to preserve architecture across languages.

### Quick Start Provide a Kotlin/Java module description to translate into a Python clean-architecture module following the rules described.

Frequently Asked Questions about clean-implementation

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

FAQPage Schema
How do I translate Kotlin Clean Architecture patterns into Python?

Translate Kotlin Clean Architecture patterns into Python by mapping domain models to Pydantic, enforcing strict isolation, and applying constructor-based dependency injection to preserve behavior across languages.

How does constructor-based dependency injection work with Pydantic models in Python?

Constructor-based dependency injection with Pydantic models works by enforcing zero-hidden state through Protocol-based dependencies, ensuring strict isolation and immutable domain models without interactive config injection.

Can I port Java use cases and interfaces to Python while preserving strict architecture?

Yes, you can port Java use cases and interfaces to Python by applying deterministic translation rules for domain layers and using builder or factory patterns to preserve strict absolute imports and architecture.

What is the best way to enforce immutable domain models during a Python code translation?

Enforce immutable domain models during Python code translation by using Pydantic-based models combined with strict isolation rules and non-interactive config injection to satisfy project constitution requirements.

Does this Clean Architecture translation approach support strict absolute imports?

Yes, this Clean Architecture translation approach supports strict absolute imports by enforcing deterministic translation of domain, use cases, and interfaces while satisfying the project constitution's architectural requirements.

When should I use Protocol-based dependencies for Python Clean Architecture?

Use Protocol-based dependencies for Python Clean Architecture when you need to translate Kotlin or Java modules while enforcing zero-hidden state and strict isolation across your domain and use case layers.