Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Config Diff

    1

    Semantic configuration diffing for JSON, YAML, and Kubernetes manifests to detect environment drift.

    $1.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Config Diff

    Config Diff

    Example session with this skill installed

    Compare deployment-dev.yaml and deployment-prod.yaml for drift. Ignore timestamp and resource version metadata.

    • Read your context and instructions
    • Compiled the config diff

    I have performed a semantic comparison between the development and production deployment manifests. Formatting differences and metadata timestamps were ignored to focus on functional configuration drift.

    Configuration Drift Analysis

    Pathdeployment-dev.yamldeployment-prod.yamlChange Type
    spec.replicas15Modified
    spec.template.spec.containers[0].resources.limits.cpu500m2000mModified
    spec.template.spec.containers[0].env[name=DB_URL]localhost:5432db.prod.internalModified
    spec.template.spec.containers[0].env[name=API_KEY]******Secret (Identical)
    metadata.annotations["debug-mode"]true(missing)Removed
    spec.strategy.rollingUpdate.maxUnavailable(missing)25%Added

    Notes:

    • metadata.creationTimestamp and metadata.resourceVersion were ignored per request.
    • Secret values for API_KEY were automatically masked.
    • Kubernetes list items were matched by their name property.

    Next steps

    1. Run with --show-secrets if you need to verify the actual API keys match.
    2. Use --json drift.json to export these differences for an automated audit report.
    3. Apply these changes to the production manifest using your CI/CD pipeline if the drift is unintentional.
    deployment-dev.yaml

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

    About this skill

    Config files rarely change in linear ways, making standard git diffs noisy and difficult to parse. This skill performs semantic comparisons of structured configuration data, ignoring key order and formatting to focus strictly on logical changes.

    What it does

    • Multi-format parsing handles JSON, YAML, TOML, INI, .env, and Java .properties files out of the box.
    • Environment drift analysis compares multiple files simultaneously to generate a side-by-side matrix of dev, staging, and production settings.
    • Deep path reporting identifies changes using full object paths, such as spec.template.spec.containers[name=api].image.
    • Secret masking automatically hides sensitive values for keys containing "password", "token", or "secret".
    • Semantic matching links Kubernetes manifests by kind and name even if they appear in a different order within a multi-document file.

    How it works

    1. Target files are provided as arguments, ranging from simple local files to outputs from tools like Kustomize or Helm.
    2. Parsing engine loads the content into a structured tree, discarding non-semantic whitespace and comment noise.
    3. Comparison logic executes a deep diff, matching list items by identifiers or position based on your configuration.
    4. Report generation outputs a clean summary of additions, removals, and value changes, or a matrix view for environment audits.

    Frameworks & tools

    Built for DevOps and SRE workflows involving Kubernetes manifests, Helm values, environment variables, and application properties. It requires Python 3.11 for native TOML support and PyYAML for manifest processing.

    Why this beats prompting it yourself

    Generic LLM diffs often hallucinate changes in large manifests or get confused by reordered keys in JSON/YAML. This skill uses deterministic parsing to ensure 100% accuracy in identifying added or modified keys, specifically handling the complexities of Kubernetes resource matching that standard diff tools miss.

    Use cases

    • Auditing environment drift between staging and production clusters.
    • Reviewing Helm chart value changes before a deployment.
    • Comparing complex Kustomize builds to verify overlay logic.
    • Troubleshooting application behavior differences across local and remote environments.

    Known limitations

    Requires PyYAML for YAML files. TOML support requires Python 3.11 or higher. Large files may require significant memory for deep-tree comparison.

    Requires PyYAML for YAML processing. TOML requires Python 3.11+. Very large files may impact performance during deep-tree recursion.

    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 month ago

    Permissions

    Terminal / Shell
    Read Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Unlike standard line-by-line diffs that flag irrelevant formatting or key order changes, this skill performs a deep semantic comparison. It understands the logical structure of the data, meaning it won't report a 'change' if keys are simply moved to a different line.

    Yes, it features specialized logic for Kubernetes resources, matching objects by their 'kind' and 'metadata.name' even if they are moved around in a multi-document YAML file or a Helm output.

    The skill includes a built-in masking engine that automatically detects and redacts values for keys containing terms like 'password', 'token', or 'secret', ensuring sensitive data isn't exposed in your logs or reports.

    It requires a Python 3.11+ environment to leverage native TOML support and the PyYAML library for manifest processing. It is designed to integrate seamlessly with any AI agent capable of executing Python-based tools.

    While highly efficient, very large manifests (thousands of lines) may require higher memory allocation for the deep-tree comparison; for typical microservice configurations and Helm charts, performance is near-instant.

    New in DevOps & Cloud