Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    context engineering

    1

    Architect, audit, and optimize context systems for coding agents, MCP workflows, and RAG pipelines.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    context engineering

    context engineering

    Example session with this skill installed

    My Claude Code agent keeps ignoring our Vitest patterns and trying to use Jest. Here is my current CLAUDE.md and a sample test file. Audit this and fix the context drift.

    • Read your context and instructions
    • Compiled the context engineering

    I have audited your CLAUDE.md and the provided test sample. The primary issue is context confusion: your instructions mention "standard JavaScript testing" which the model is defaulting to Jest, while your file structure uses .test.ts with Vitest-specific globals.

    Context Audit & Repair for Vitest Migration

    FindingImpactRecommended Fix
    Ambiguous ToolingAgent defaults to Jest globals (describe, it)Explicitly define Vitest as the sole test runner in CLAUDE.md.
    Missing CommandsAgent guesses npm test which failsAdd specific Vitest CLI commands to the Test Commands section.
    Pattern StarvationNo example of a Vitest mock in contextAdd a concise "Golden Example" block for component mocking.
    Context PoisoningStale reference to setupTests.jsRemove legacy Jest setup references from the project rules.

    Updated CLAUDE.md Section

    
    ## Testing Conventions
    - Use Vitest for all unit and integration tests.
    - Test files must reside in `src/**/__tests__/*.test.ts`.
    - Use `vi.mock()` for dependency injection; do not use `jest.mock()`.
    - Run specific test: `npx vitest run <path>`
    - Run all tests: `npm run test:ci`
    
    ## Golden Example (Vitest)
    import { vi, test, expect } from 'vitest';
    import { service } from './service';
    test('logic', () => {
      const spy = vi.spyOn(service, 'call');
      // ... test logic
    });
    

    Next steps

    1. Replace the ## Testing section in your root CLAUDE.md with the updated block above.
    2. Run npx vitest run and provide the output to the agent to verify it recognizes the environment.
    3. If the agent still confuses syntax, we should implement a .cursorrules file for editor-level enforcement.
    Updated CLAUDE.md

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

    About this skill

    The problem

    Coding agents and RAG pipelines often suffer from context collapse, hallucinated APIs, or token waste. Developers struggle to manage the boundaries between static instructions, dynamic project rules, and retrieved knowledge, leading to degraded agent performance over long sessions.

    What it does

    • Designs structured CLAUDE.md, AGENTS.md, and .cursorrules files to enforce project conventions.
    • Audits existing context setups to identify starvation, poisoning, or conflicting instructions.
    • Creates multi-agent handoff packets that preserve state, authority, and evidence across transitions.
    • Develops retrieval strategies and memory architectures for RAG systems to minimize noise.
    • Builds context compression and eviction plans to stay within token budgets without losing critical detail.

    Frameworks & tools

    Claude Code, Cursor, GitHub Copilot, MCP (Model Context Protocol), RAG architectures, and agentic workflows.

    Why this beats prompting it yourself

    Writing a good prompt is not enough for complex agents. This skill applies information architecture to context, separating static rules from dynamic state. It prevents context drift by establishing formal quality gates and handoff contracts that work across multi-turn loops.

    Use cases

    • Setting up a new repository for Claude Code or Cursor with strict architectural rules.
    • Diagnosing why an agent is missing local testing conventions or hallucinating legacy code.
    • Defining the data contract and escalation paths for a multi-agent orchestration system.
    • Optimizing a RAG pipeline's context window by ranking and compressing retrieved artifacts.

    Known limitations

    Does not modify live source code directly without a prior design review. Requires manual input of environment-specific constraints like token limits or write permissions.

    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 explicit environment details (e.g., Claude Code vs Cursor). Does not perform code edits directly. User must provide repo structure or existing rules for audits.

    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 2 months ago

    Permissions

    No special permissions declared or detected

    Listed2 months ago

    What's inside

    Frequently Asked Questions

    This skill provides a structured architecture for your agent's memory and instructions, preventing 'context collapse' and hallucinations by defining clear boundaries between project rules, retrieved data, and active task state.

    The skill is optimized for environments that support Model Context Protocol (MCP) and custom instruction files, including Claude Code, Cursor (.cursorrules), GitHub Copilot, and custom RAG-based agentic workflows.

    You will receive a comprehensive implementation kit featuring templated architectures for CLAUDE.md and AGENTS.md, multi-agent handoff protocols, and a framework for context compression and eviction strategies.

    Setup involves integrating the provided architectural templates into your repository's root and configuring your agent's context window settings according to the included optimization guide.

    While the skill doesn't automate code changes, it provides the 'rules of engagement' and state-management protocols that guide your agents to write more accurate, architecturally sound code without manual oversight.

    Yes, the purchase includes periodic updates to the templates and protocols as new standards like MCP evolve or as tools like Cursor and Claude Code update their context handling capabilities.

    New in Agents & Orchestration