Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    dev conductor

    1

    Orchestrate multi-domain software tasks by sizing complexity and routing phases to specialist skills.

    Free

    1 useSecurity scanned
    dev conductor

    dev conductor

    Example session with this skill installed

    I need to add a new billing page that lets users upgrade their plan. It will touch the database, Stripe webhooks, and the React frontend. How should we proceed?

    • Read your context and instructions
    • Compiled the dev conductor

    I have analyzed the request and detected the project stack. This is a Tier 3 Heavy task because it involves database schema changes, payment processing via Stripe webhooks, and sensitive pricing logic.

    Task Execution Plan

    PhaseDomainSpecialist SkillFallback
    PlanSystemwayfinderreferences/heavy.md
    DesignFrontenddesign-taste-frontendreferences/frontend.md
    ImplementationBackendprisma-expertreferences/backend-data.md
    Security AuditSecuritysecurity-checkreferences/security-checklist.md
    VerificationQAplaywright-expertManual Test Plan

    Tier 3 Signal Detection:

    • Database: New Subscription model required.
    • Payments: Stripe webhook integration and billing logic.
    • Security: Requires PII handling and session validation for checkout.

    Next steps

    1. Run python3 -I dev-conductor/scripts/detect_stack.py to confirm current ORM and test runner versions.
    2. Generate the technical specification at docs/specs/2024-05-20-billing-upgrade.md.
    3. Load the wayfinder skill to map out the implementation slices.

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

    About this skill

    Software tasks often stall when the complexity is high and the right tools are not sequenced correctly. You end up with fragmented PRs or technical debt because a small fix touched a sensitive auth layer without the proper checks.

    What it does

    • Task sizing categorizes work into Tiers to apply the correct amount of process and safety overhead.
    • Specialist routing maps specific task phases like debugging, design, or schema changes to the most appropriate installed skills.
    • Stack detection identifies the frontend, backend, and infrastructure layers to ensure domain-specific rules are applied.
    • Safety gating enforces strict rules around destructive commands, PII, and credential handling based on project-level configurations.

    How it works

    1. Fact-finding starts with running stack detection and routing scripts to identify available tools and repository constraints.
    2. Tier assessment analyzes signals like schema changes or payment logic to determine if the task is Standard or Heavy.
    3. Domain mapping loads specific procedures for frontend, backend, or security-sensitive areas based on what the code touches.
    4. Execution routing hands off specific phases to specialist skills while maintaining the overall lifecycle and safety gates.

    Frameworks & tools

    This skill uses Python scripts for environment detection and is designed to coordinate specialized agents across React, Next.js, Node.js, Prisma, and cloud infrastructure.

    Why this beats prompting it yourself

    Manual prompting often misses cross-domain side effects or skips critical verification steps when tasks get complex. This skill automates the decision of when to be cautious, ensuring migrations and security changes get tier-3 oversight while simple fixes stay fast.

    Use cases

    • Orchestrating a feature that requires both a database migration and a UI update.
    • Routing a complex bug fix through specialized debugger and reviewer skills.
    • Enforcing safety gates during sensitive refactors involving auth or PII.
    • Managing multi-session project roadmaps using structured planning directories.

    Known limitations

    Requires Python 3.9+ for stack detection scripts. Does not automate the installation of missing specialist skills, as this requires manual user approval.

    Requires Python 3.9+. User must manually approve skill installations. Performance depends on the presence of specialist skills in the session.

    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 any payment.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Python
    Node.js
    and
    or

    Permissions

    Terminal / Shell
    Browser
    Network Access
    Environment Variables
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    The skill analyzes code signals—such as modifications to payment logic, database schemas, or authentication layers—to automatically categorize tasks as Standard or Heavy, applying stricter safety gates to high-risk changes.

    It works as an orchestration layer designed to coordinate with specialist agents for React, Next.js, Node.js, and Prisma, though it requires Python 3.9+ to run its internal environment detection scripts.

    No, while the skill identifies which domain-specific tools are needed for a task, you must manually approve and install the recommended specialist skills to maintain full control over your environment.

    You receive the core orchestration logic, the Python-based stack detection scripts, and the tiered safety gate configurations to manage cross-domain software tasks.

    By automating 'Fact-finding' and 'Domain mapping,' the skill ensures that cross-domain side effects—like a backend change breaking a frontend UI—are caught by routing the work through the correct verification steps every time.

    New in Agents & Orchestration