Scaffold platform-agnostic apps with contract-port architecture and dependency injection.
npx skills add https://github.com/Anveio/conveaux --skill app-architecture
Please help me install this Agent Skill. Skill: app-architecture Source: https://github.com/Anveio/conveaux/tree/main/.claude/skills/app-architecture Command: npx skills add https://github.com/Anveio/conveaux --skill app-architecture
This Skill automates the creation of platform-agnostic applications following established architectural patterns.
When creating new apps or scaffolding CLI tools, invoke this Skill to apply standard app architecture patterns.
When creating new apps in apps/, setting up dependency injection, or when the user asks about app structure, use this Skill to ensure proper architectural separation.
Use this Skill when building applications to ensure they follow contract-port architecture with proper composition roots.
High-intent search queries and answers about installing and using this skill.
Contract-port architecture eliminates platform dependencies by enforcing a composition root where all runtime dependencies are explicitly assembled at startup. This approach isolates platform-specific globals, wires modules through ports, and injects dependencies into domain logic rather than allowing globals, making your app portable across environments.
A composition root is the single entry point where your application instantiates and wires all dependencies before execution. It centralizes dependency assembly, prevents scattered global state, and makes platform dependencies explicit and testable. This Skill scaffolds composition roots automatically in new apps.
Contract-port architecture segregates platform concerns from domain logic by defining ports—interfaces through which domain modules receive dependencies. The Skill scaffolds this structure in apps/, setting up dependency injection so domain modules never reference platform-specific globals directly.
Yes. This Skill handles scaffolding CLI tools with proper architectural separation, applying the same composition root and dependency injection patterns to ensure CLI commands stay platform-agnostic and testable.
Ports are abstract interfaces your domain modules depend on; entrypoints are platform-specific implementations that satisfy those ports. This separation lets you swap implementations without changing domain code, and the Skill enforces this boundary during app structure setup.
Apply it when platform dependencies are scattered across your codebase, making testing and porting difficult. This Skill is most effective for new apps or CLI tools where you can establish the pattern early; for existing codebases, it answers questions about refactoring app structure toward this model.
lucidfrontier45Validate code placement and dependency directions across Domain, Use Case, Infrastructure, Entrypoint, and Shared layers.
AugustEmnaConfigure production settings, publish deployments, and analyze post-deploy logs.
crsieblerImplement software features using test-driven development and dependency injection.
vanstinatorDesign dependency injection in Go using constructor injection and consumer-defined interfaces.
