Project Kit

    1

    Generate a CLAUDE.md from what your repo really contains, keep it current, and decide when a task is worth a subagent — without burning quota on delegation that doesn't pay.

    $5

    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 CLIMuseMuseDotsDots+21 more

    Project Kit

    Example session with this skill installed

    I just cloned this repo and it has no instructions. Write a CLAUDE.md for it and tell me if I should use a subagent to map the data flow.

    • Read your context and instructions
    • Compiled the project kit

    I have analyzed the repository structure. It appears to be a TypeScript project using Vite and Vitest. I have drafted a CLAUDE.md based on the discovered scripts and patterns. Regarding your request to map data flow: this is a high-context architectural task involving multiple modules, so I recommend delegating this to a subagent using a long-context model.

    CLAUDE.md Draft

    
    # Project Guide: Vite-TS-App
    
    ## Build & Test Commands
    - Build: `npm run build`
    - Dev: `npm run dev`
    - Test: `npm run test`
    - Lint: `npm run lint`
    
    ## Project Structure
    - `src/components`: UI components (React)
    - `src/hooks`: Custom React hooks
    - `src/services`: API logic and data fetching
    - `src/types`: TypeScript interfaces/types
    
    ## Style & Patterns
    - Use functional components with hooks.
    - Prefer `interface` over `type` for public APIs.
    - All new features require a corresponding `.test.ts` file.
    

    Delegation Recommendation

    Decision: Delegate to Subagent
    Recommended Model: Claude 3.5 Sonnet (or equivalent long-context model)
    Briefing Template:

    Task: Map data flow from API services to UI components.
    Focus: Trace UserService.ts through useAuth hook to Navbar component.
    Output: Return a concise summary of the lifecycle, including file paths and key function names. Do not provide raw logs.

    Next steps

    1. Approve the CLAUDE.md content to save it to the root directory.
    2. Initialize the subagent using the provided briefing template.
    3. Run npm run test to verify the current environment state.
    project using Vite and Vitest. I have drafted a CLAUDE.md

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

    About this skill

    Onboarding a new agent to a legacy repository often leads to hallucinated build commands and ignored style guides. This skill anchors agent behavior to the reality of your codebase by generating and maintaining precise instruction files.

    What it does

    • Repo Analysis scans your project structure to identify actual build, test, and lint commands.
    • CLAUDE.md Generation creates a project-specific guide including directory maps, tech stacks, and "Definition of Done."
    • Instruction Auditing reviews existing guide files against current repository state to fix drift or missing rules.
    • Delegation Logic evaluates task complexity to decide if a job stays inline or moves to a subagent.
    • Subagent Briefing generates structured prompts that force subagents to return concise summaries instead of unparsed logs.

    How it works

    1. Trigger the skill using init or delegate commands when starting a repo or facing a large task.
    2. The agent crawls the file system to extract real paths, scripts, and configuration patterns.
    3. For instruction updates, the skill proposes a merge rather than overwriting existing files.
    4. For heavy tasks, it outputs a model recommendation and a specific briefing template.

    Frameworks & tools

    This skill is optimized for environments using CLAUDE.md or AGENTS.md conventions. It works across any stack by reading standard package managers, test runners, and configuration files like package.json, pyproject.toml, or Makefile.

    Why this beats prompting it yourself

    Generic prompts often result in vague advice like "write clean code." This skill forces the agent to use the exact commands found in your repo, preventing broken builds and ensuring subagents stay within scope without burning unnecessary tokens.

    Use cases

    • Generate a CLAUDE.md for an unfamiliar repository to start working immediately.
    • Update stale project instructions after a major refactor or stack migration.
    • Determine if a complex bug investigation justifies the cost of a subagent.
    • Create high-density briefs for subagents to ensure actionable summaries.

    Known limitations

    Does not support overwriting existing files without manual approval. Effectiveness depends on the presence of standard configuration files for command detection.

    Requires existing project files to detect commands. Will not overwrite instruction files automatically. Scope is limited to repo-based instructions and delegation logic.

    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

    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 1 day ago

    Permissions

    Read Files
    Write Files
    Terminal / Shell
    Listed1 day ago

    What's inside

    Frequently Asked Questions

    This skill automates the creation of repo-specific instruction files (like CLAUDE.md) that force AI agents to follow your project's actual build, test, and style rules instead of hallucinating them.

    It is optimized for agents that support file-system access and local command execution, specifically those following CLAUDE.md or AGENTS.md conventions.

    The skill functions as a cross-platform analyzer that detects project intent by reading standard configuration files like package.json, pyproject.toml, or Makefiles, regardless of the programming language.

    When a task is too large for a single context, the skill analyzes the complexity and generates a structured, high-density brief to ensure subagents return actionable results rather than verbose logs.

    No, the skill is designed to propose updates or merges to your existing documentation, ensuring you retain manual control over your project guidelines while fixing technical drift.

    New in Productivity