Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    SkillGuard Pro Authoring Engine (skill-creator)

    1

    A deterministic pipeline for diagnosing task friction and authoring safety-gated, evidence-based agent skills.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    SkillGuard Pro Authoring Engine (skill-creator)

    SkillGuard Pro Authoring Engine (skill-creator)

    Example session with this skill installed

    Diagnose the failure in the data-processing task and author a gated skill for handling parquet-to-csv conversion errors in the /skills directory.

    • Read your context and instructions
    • Compiled the skillguard pro authoring

    I have diagnosed the friction in the data-processing task. The failure was caused by a schema mismatch in the Parquet reader when encountering null timestamps. I have authored and gated a new skill to handle this specific constraint.

    Skill Creation Log

    StepActionStatusDetail
    1Diagnostic ProbeSUCCESSLogged friction: pyarrow.lib.ArrowInvalid on null timestamps (Run ID: 8829)
    2Author CandidateSUCCESSCreated parquet-schema-guard with explicit type-casting steps.
    3Safety GatePASSTier: DIAGNOSED. Passed all 12 safety checks.
    4Library PromotionSUCCESSSkill promoted to generated_skills_root/parquet-schema-guard/SKILL.md.
    
    # parquet-schema-guard
    
    ## Overview
    Gards against Arrow schema mismatches during Parquet-to-CSV conversion, specifically targeting null timestamp handling.
    
    ## Pipeline
    1. Inspect Parquet metadata using `pyarrow.parquet.read_metadata`.
    2. If null timestamps are present, define an explicit schema mapping all timestamp columns to `pa.string()`.
    3. Execute conversion using `read_table` with the defined schema to avoid `ArrowInvalid` crashes.
    
    ## Scope Guard
    - Do not attempt conversion without metadata inspection.
    - Do not use `pandas.read_parquet` without explicit `dtype` overrides.
    
    <!-- evidence: 8829 -->
    

    Next steps

    • Verify the solver agent picks up the parquet-schema-guard skill in the next turn.
    • Monitor the ledger.py outcome to confirm the schema guard resolves the crash.
    • Run forge.py status to see if this skill needs merging with other data-processing utilities.

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

    About this skill

    Manual prompting for complex agent tasks often fails because LLMs rely on vague guesses rather than environment-specific constraints. This skill provides a structured pipeline to diagnose real task friction and author safety-gated domain skills that actually improve solver performance.

    What it does

    • Evidence-based diagnosis runs read-only probes to identify exact API limitations or file format pitfalls before authoring instructions.
    • Automated safety gating enforces deterministic checks to prevent leaked instructions, oversized contexts, or unsafe commands.
    • Stateful skill refinement merges new observations into existing domain skills to prevent library bloat and performance collapse.
    • Harness-alignment fallback generates minimal safety-gated skills for reasoning-only tasks to satisfy environment requirements without hallucinating procedures.
    • Outcome tracking logs hits and misses to archive underperforming skills automatically via a retention counter system.

    How it works

    1. Probe: Execute forge.py log-probe to record the concrete failure mode and generate a unique run_id.
    2. Author: Write a compact skill based on the gold template, incorporating the specific friction found during probing.
    3. Gate: Run safety_gate.py to validate the candidate against safety and quality rules; failures must be revised until they pass.
    4. Promote: Use ledger.py to move the validated skill into the library and link it to the evidence IDs.

    Frameworks & tools

    This skill utilizes a Python-based toolchain including forge.py, safety_gate.py, and ledger.py. It produces standard SKILL.md files compatible with agentic frameworks that support modular skill injection.

    Why this beats prompting it yourself

    Generic system prompts often fail to account for the specific technical edge cases of a workspace. This skill replaces "best guesses" with a deterministic pipeline that validates every instruction against a safety gate, ensuring a +19pp lift in task success rather than the typical performance drop associated with self-generated prompts.

    Use cases

    • Generating domain-specific instructions for agents handling unfamiliar library APIs.
    • Creating safety-gated execution plans for high-stakes deployment environments.
    • Managing a growing library of agent skills by merging and archiving based on real-world outcomes.
    • Converting observed task failures into permanent, reusable safety guards for future agents.

    Known limitations

    Requires the presence of the scripts/ directory containing the forge and safety tools. Not designed to solve tasks directly, only to author the governing skills.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Prompt & Skill Engineering.

    Requires scripts/forge.py, safety_gate.py, and ledger.py in the environment. Designed for creator turns, not for direct task execution. State persistence requires runs.jsonl.

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

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Environment Variables
    Listed6 days ago

    What's inside

    Frequently Asked Questions

    Unlike manual prompting, this skill uses a deterministic pipeline (Probe-Author-Gate) that validates instructions against real environment constraints and safety rules before they are deployed. This prevents the "hallucination creep" often seen when agents try to self-correct without structured evidence.

    The skill produces standard SKILL.md files and works with any Python-based agentic framework that supports modular skill injection. It requires a local `scripts/` directory to run its core validation and ledger tools.

    You receive the complete Python-based toolchain, including forge.py for diagnosis, safety_gate.py for automated validation, and ledger.py for library management. It also includes the 'gold templates' used to structure high-performance, safety-gated skills.

    The skill includes a stateful refinement system and a retention counter via ledger.py. It automatically merges overlapping observations to prevent library bloat and archives underperforming skills based on real-world hit/miss logs.

    The 'Safety Gate' component enforces deterministic checks to prevent oversized contexts, unsafe command generation, and instruction leakage. Every authored skill must pass these automated quality gates before it can be promoted to your active library.

    New in Prompt & Skill Engineering