Agent Setup

    1

    Scaffold a project-local team of specialized subagents grounded in your repository's stack and conventions.

    $2

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    agent-setup

    Example session with this skill installed

    /agent-setup in this repo. It's a TypeScript Next.js app with Prisma and Vitest.

    • Read your context and instructions
    • Compiled the agent-setup

    I have analyzed the repository structure. Based on the presence of package.json, prisma/schema.prisma, and vitest.config.ts, I am scaffolding a specialized agent team for the web-portal project.

    Created the following agents in ./.claude/agents/:

    • web-portal-dev.md: Implements features using Next.js conventions and Vitest.
    • web-portal-reviewer.md: Read-only agent for diff analysis and PR readiness.
    • web-portal-testing.md: Specialized for writing and maintaining Vitest suites.
    • web-portal-data-expert.md: Grounded in Prisma schema for migrations and DB logic.

    Project Agent Team

    RoleFileCapabilities
    Developerweb-portal-dev.mdFeature implementation, Next.js API routes, UI components.
    Reviewerweb-portal-reviewer.mdRead-only code review, linting check, logic validation.
    Testingweb-portal-testing.mdUnit and integration testing via npm run test.
    Data Expertweb-portal-data-expert.mdPrisma migrations, schema optimization, seed scripts.

    Next steps

    • Review the generated .md files in .claude/agents/ to ensure the specific commands match your local aliases.
    • Invoke a specific agent by name, e.g., @web-portal-reviewer, when you are ready to check your staged changes.
    • Add these files to your .gitignore if you prefer them to stay local, or commit them to share the agent team with your collaborators.

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

    About this skill

    Stop manually configuring project-specific agent instructions for every new repository. This skill automates the creation of a localized agent team tailored to your specific codebase, stack, and architectural patterns. It prevents configuration drift by grounding every agent in your project's actual source code, directory structures, and CI conventions.

    The skill avoids the common mistake of polluting global agent configurations with project-specific paths or internal service names. By writing directly to your repository's local configuration directory, it ensures that your team's specialized knowledge—like specific migration workflows or test suites—stays within the project context where it belongs.

    What it does

    • Repo grounding resolves the absolute project root to ensure all generated agents operate within the correct local scope.
    • Stack investigation analyzes package.json, go.mod, Cargo.toml, and other manifest files to detect languages and build tools.
    • Role derivation determines the optimal set of subagents, such as developers, reviewers, or architects, based on project complexity.
    • Local scaffolding writes specialized Markdown agent definitions directly to the project's .claude/agents/ directory.
    • Conflict prevention checks for existing agent slugs and prompts for refresh or skip to protect manual edits.

    How it works

    1. Ground the target by resolving the git root or current working directory to scope all subsequent file operations.
    2. Investigate the repo via targeted greps and file reads to identify testing frameworks, database migrations, and monorepo structures.
    3. Decide the role set by selecting roles like dev, reviewer, or data-expert based on the signals found during investigation.
    4. Write the agents as individual Markdown files with specific tool access and instructions grounded in the repo's real commands.

    Frameworks & tools

    This skill works with any language detected in the repo, including JavaScript/TypeScript, Go, Rust, Python, and Java. It integrates with standard build tools and version control systems using git and bash.

    Why this beats prompting it yourself

    Writing project-specific instructions manually is repetitive and prone to path errors. This skill ensures your agents know the exact test commands and module boundaries of your current repo without you having to explain them every time you start a new session.

    Use cases

    • Scaffold a pair of dev and reviewer agents for a new microservice.
    • Generate a specialized data-expert agent for a repo containing complex SQL migrations.
    • Create an architect agent for large monorepos to handle design planning.
    • Refresh existing agent instructions after a major refactor or stack change.

    Known limitations

    The skill requires a local .claude/agents/ directory structure to exist or be created within the project root. It does not automatically commit generated files to version control.

    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 git or a standard project structure to resolve root. Does not stage or commit files. Limited to local project scope.

    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 18 days ago

    Software
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed18 days ago

    What's inside

    Frequently Asked Questions

    This skill eliminates the manual task of writing project-specific instructions by scanning your codebase to automatically generate subagents (like 'Dev' or 'Reviewer') that already know your specific test commands, file structures, and tech stack.

    The skill is designed to work with any repository that has a clear structure, automatically detecting frameworks across JavaScript, Go, Rust, Python, and Java. It specifically generates Markdown-based agent definitions compatible with the Claude desktop app and other agent platforms that support local configuration directories.

    No, the skill writes directly to your local `.claude/agents/` directory rather than your global profile. This ensures that project-specific details, like internal service names or local paths, stay contained within the relevant repository and don't interfere with your other projects.

    Simply run the skill within your project root; it will ground itself to your Git directory, analyze your manifest files (like package.json or go.mod), and scaffold the necessary agent files automatically. It even checks for existing files to ensure you don't accidentally overwrite manual customizations.

    Yes, you can run the skill at any time to refresh your subagents. It is particularly useful after a major refactor or when switching libraries, as it will re-scan the repo to ensure your agents' instructions remain aligned with your current architectural patterns.

    New in Agents & Orchestration