library-design-patterns

Identify and articulate standardized design patterns for Python libraries in the autonomous-dev ecosystem.

32|5|Updated Oct 19, 2025
One-click install
npx skills add https://github.com/akaszubski/autonomous-dev --skill library-design-patterns
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: library-design-patterns
Source: https://github.com/akaszubski/autonomous-dev/tree/main/plugins/autonomous-dev/skills/library-design-patterns
Command: npx skills add https://github.com/akaszubski/autonomous-dev --skill library-design-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill defines standardized library design patterns (two-tier design, progressive enhancement, non-blocking enhancements, security-first architecture) to improve reusability and maintainability.

Core Features & Use Cases

  • Two-tier design pattern: core library + CLI wrapper
  • Progressive enhancement: incremental validation and security
  • Non-blocking enhancements: degrade gracefully
  • Security-first architecture and docstring standards

Quick Start

Use the two-tier pattern to structure a new Python library.

Frequently Asked Questions about library-design-patterns

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

FAQPage Schema
How do I structure a Python library for reusability and maintainability?

Use two-tier design: separate the core library logic from CLI wrapper interfaces. This pattern improves reusability, testability, and modularity by decoupling business logic from command-line concerns, enabling the library to be imported and used programmatically across the autonomous-dev ecosystem.

What's the best way to handle security validation in library design?

Implement security-first architecture with input validation, audit logging, and CWE-22/CWE-78-informed practices. Progressive enhancement lets you add validation incrementally without breaking existing code, while non-blocking enhancements allow graceful degradation when security checks fail.

How do I build a CLI that wraps a reusable Python library?

Apply the two-tier pattern: keep the CLI as a thin wrapper around a core library. Document APIs with comprehensive docstrings, use separation of concerns to isolate CLI logic from library logic, and ensure the core remains importable independently for programmatic use.

Can I add features to a library without breaking existing code?

Yes, use progressive enhancement and non-blocking enhancements. These patterns let you layer new functionality—including security checks and validation—incrementally. Code degrades gracefully when enhancements aren't available, preserving backward compatibility.

What security vulnerabilities should I address in library design?

Document and mitigate CWE-22 (path traversal), CWE-59 (link following), CWE-78 (command injection), and CWE-117 (log injection). Security-first architecture embeds input validation and audit logging into design from the start, reducing exposure across all library consumers.

Why separate concerns between library code and CLI interfaces?

Separation of concerns isolates testability, reusability, and security logic. Libraries can be used in multiple contexts—CLI, imports, server plugins—without duplicating validation or audit logic. This design supports the modular, autonomous-dev plugin ecosystem.