rules-flext-core

Validate flext-core Python code against architectural, typing, and result flow rules.

Updated May 20, 2025
One-click install
npx skills add https://github.com/flext-sh/flext --skill rules-flext-core
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rules-flext-core
Source: https://github.com/flext-sh/flext/tree/main/.claude/skills/rules-flext-core
Command: npx skills add https://github.com/flext-sh/flext --skill rules-flext-core

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill ensures that all code modifications within the flext-core directory adhere to established architectural principles, typing conventions, and result flow patterns, preventing architectural drift and maintaining code quality.

Core Features & Use Cases

  • Architectural Alignment: Enforces inward dependency direction and centralized type contracts.
  • Result Flow Enforcement: Promotes the use of FlextResult for robust error and success handling.
  • Dependency Management: Guides the correct usage of dependency injection patterns.
  • Use Case: When a developer modifies a file in flext-core/src/flext_core/, this Skill automatically checks if the changes align with the defined rules for result composition and dependency injection, flagging any deviations.

Quick Start

Run the flext-core verification checks for the flext-core project.

Frequently Asked Questions about rules-flext-core

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

FAQPage Schema
How do I enforce architecture rules in Python projects to prevent architectural drift?

This validation checks Python files against architectural, typing, and result flow rules. It validates dependency inversion, enforces standardized result composition using FlextResult, and ensures correct dependency injection patterns.

What is the best way to validate dependency injection patterns in Python?

The best way to validate dependency injection is using a rules engine that checks Python files against architectural constraints. It enforces inward dependency direction and standardized result composition for robust error and success handling.

How do I standardize error handling and result composition in Python?

Standardizing result composition requires enforcing the use of FlextResult across Python code changes. This ensures robust error and success handling while maintaining alignment with architectural principles and typing conventions.

When do I need to run architecture validation checks on my code?

Architecture validation checks are needed when modifying files in the source directory. The validation automatically checks if changes align with defined rules for result composition, dependency injection, and typing conventions, flagging any deviations.

Does this validation work with documentation files or only Python source code?

This validation works with both Python source files and documentation files. It targets Python files within the source directory and documentation in the architecture directory to ensure comprehensive adherence to architectural rules.