Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Engineering delivery

    1

    A sophisticated engineering router that dispatches tasks to specialized roles and gated delivery pipelines.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Engineering delivery

    Engineering delivery

    Example session with this skill installed

    I need to add a new user notification system. Can you architect the module and design the API interface before we start coding?

    • Read your context and instructions
    • Compiled the engineering delivery

    I have routed this task to the software-architect module to ensure a structured design phase.

    Software Architecture Design: User Notification System

    The design focuses on a decoupled, provider-agnostic interface to support multiple delivery channels (Email, SMS, Push).

    ComponentDescriptionResponsibility
    NotificationDispatcherCentral OrchestratorResolves user preferences and routes to specific providers.
    NotificationProviderInterfaceAbstract contract for external service integration.
    TemplateEngineHelperInjects dynamic data into pre-defined message templates.
    NotificationStorePersistenceLogs delivery status and audit trails for re-tries.

    Proposed API Interface

    interface NotificationRequest {
      recipientId: string;
      templateId: string;
      payload: Record<string, any>;
      priority: 'low' | 'medium' | 'high';
    }
    
    interface NotificationResult {
      messageId: string;
      status: 'queued' | 'sent' | 'failed';
      timestamp: Date;
      provider: string;
    }
    
    abstract class NotificationProvider {
      abstract send(request: NotificationRequest): Promise<NotificationResult>;
    }
    

    Evidence of Verification

    • Module Selected: software-architect.md via Routing Rule 4 (Unclear structure).
    • Architecture Defined: Defined a provider-agnostic interface and component registry.
    • Constraints Checked: System follows the project's requirement for decoupled services.
    • Review Status: Ready for independent modules/reviewer.md pass.

    Next steps

    1. Dispatch an independent-reviewer to validate the interface against existing services.
    2. Once the design is approved, route to database-engineer for the persistence schema.
    3. Initiate the feature-delivery pipeline for implementation.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Software engineering tasks often fail when agents jump straight to coding without the proper discipline. This skill acts as a dedicated router that forces every task through a specific engineering role or gated pipeline, ensuring that architecture, security, and QA are never treated as mere formalities.

    What it does

    • Role-based Routing identifies the correct discipline for a task, such as software-architect, database-engineer, or security-engineer.
    • Gated Pipelines manages complex workflows like feature delivery or refactoring through mandatory stages and review gates.
    • Isolated Execution dispatches tasks to subagents with targeted context to prevent "role-blind" work and context bloating.
    • Independent Review enforces a reviewer protocol where design and plan reviews must be handled by a fresh context, not the author.
    • Verification Enforcement validates subagent output against strict module-specific evidence tables before accepting work as complete.

    How it works

    1. The router analyzes the incoming request to determine if it requires a specific role or a multi-stage pipeline.
    2. It selects the appropriate module file from the internal library and constructs a structured dispatch prompt.
    3. The task is executed via a subagent (or a main-session fallback) following the module's specific workflow and constraints.
    4. The router verifies the artifacts against the module's internal verification table and reports the evidence to the user.

    Frameworks & tools

    This skill is framework-agnostic and works with any environment providing file read access. It is optimized for agents with subagent delegation capabilities like Claude Code or Cursor but includes logic for single-session execution.

    Why this beats prompting it yourself

    Generic prompts often lead to agents self-approving flawed designs or skipping security checks to finish a task quickly. This skill enforces structural separation, ensuring that the "implementer" and "reviewer" are never the same entity and that every schema change or refactor follows industry-standard safety protocols.

    Use cases

    • Executing end-to-end feature delivery with design and plan review gates.
    • Performing behavior-preserving refactors on legacy codebases.
    • Conducting exploitability-driven security audits and threat modeling.
    • Managing zero-downtime database schema migrations and query optimizations.

    Known limitations

    Does not provide framework-specific API documentation or one-line factual answers. Requires the host agent to have file system access to read its internal modules and reference files.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires file system access. Not for framework-specific how-to or trivial fixes. Best used with agents supporting subagent delegation.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 17 days ago

    Software
    Git

    Permissions

    Network Access
    Read Files
    Write Files
    Listed17 days ago
    Updated12 days ago

    What's inside

    Frequently Asked Questions

    This skill solves 'agent drift' by preventing agents from self-approving low-quality code. It enforces a structural separation of concerns, ensuring tasks like architecture and security are handled through mandatory gated pipelines rather than as a single, unverified coding step.

    The skill is framework-agnostic and optimized for any agent with subagent delegation or file-system access, including Claude Code and Cursor. It can also run in a single-session fallback mode for environments that do not support independent sub-tasks.

    You receive the core router logic along with a library of specialized module files for roles like Security Engineer and Software Architect. It also includes the verification evidence tables used to validate subagent output.

    No, this skill focuses on the discipline and workflow of engineering rather than specific library knowledge. It is designed to manage the process of delivery, requiring the host agent to use its own training or external documentation for specific API syntax.

    Installation involves placing the module library within your agent's accessible directory. Once the agent has file-read access, you can trigger the router by delegating engineering tasks to it via your standard chat interface.

    Independent review ensures that the design and plan for a task are validated by a 'fresh' subagent context rather than the one writing the code. This prevents the original agent from overlooking its own logical flaws or security gaps.

    New in Agents & Orchestration