Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseOpenClawOpenClaw+21 more

    PlaceholderGuard: Real Time AI Stream & Code Lazy Filter

    1

    Real-time streaming middleware to detect and block lazy LLM code placeholders before they corrupt your workspace.

    $39

    Secure checkout via Stripe

    30-day refund guarantee

    Converts to your local currency at checkout

    Security scanned
    PlaceholderGuard: Real Time AI Stream & Code Lazy Filter

    PlaceholderGuard: Real Time AI Stream & Code Lazy Filter

    Example session with this skill installed

    Route this streaming line through the filter: `

    ... rest of the function remains the same ...` for a .py file inside a function body.

    • Read your context and instructions
    • Compiled the placeholderguard

    The stream interceptor detected a lazy placeholder pattern in the active buffer. The following JSON resolution report was generated for the host pipeline to trigger a recovery injection.

    Stream Filter Verdict Report

    {
      "filter_verdict": "ABORT",
      "stream_action": {
        "emit_token": false,
        "inject_recovery_prompt": true,
        "recovery_prompt_payload": "Re-emit the full block. No placeholders. The entire function body must be expanded line by line — no '# ... unchanged', no '...', no 'тут код'."
      },
      "telemetry": {
        "triggered_pattern": "western_lazy_ellipsis",
        "current_retry_count": 1
      }
    }
    

    Next steps

    1. Block Buffer: Prevent the current line from being committed to the file writer or frontend UI.
    2. Re-prompt: Send the recovery_prompt_payload back to the LLM to restart the generation for this block.
    3. Increment Counter: Update your local session state to track the retry count against the hard cap of 2.

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

    What you get

    Prevent truncated code snippets from overwriting local source files.Inject automated recovery prompts when agents attempt to skip code.Standardize code generation output across different LLM providers.Enforce full code expansion in automated CI/CD refactoring pipelines.

    About this skill

    LLMs frequently truncate code with lazy placeholders like // ... rest unchanged, breaking automated pipelines and IDE syncs. This skill provides a high-performance streaming middleware that intercepts these tokens in real time, preventing corrupted files from reaching your workspace.

    What it does

    • Stream Interception binds to the model's active token stream to evaluate lines before they hit the frontend buffer.
    • Pattern Matching utilizes a multilingual blocklist to detect lazy compression markers across different languages and locales.
    • AST Context Check distinguishes between lazy shortcuts and legitimate language features like Python type stubs or abstract methods.
    • Recovery Injection pushes automated re-prompts back to the model context to force full code expansion upon detection.
    • Execution Guardrails enforces a hard retry cap of two iterations to prevent infinite loops in automated generation cycles.

    How it works

    1. Route the active model token stream through the filter's execution schema, including current file extension and AST scope.
    2. The middleware evaluates the stream buffer against the regex matching matrix and multilingual blocklist.
    3. If a lazy marker is detected, the filter returns an ABORT verdict and a specific recovery prompt payload for the LLM.
    4. Integrate the machine-readable JSON report into your downstream pipeline to handle stream termination or retries.

    Frameworks & tools

    This tool is designed for integration with custom IDE extensions, agent runtimes, and CI/CD code-gen pipelines. It requires a streaming output layer like SSE or WebSockets and can be enhanced with AST parsers like @babel/parser or Python ast.

    Why this beats prompting it yourself

    System prompts often fail to stop lazy behavior, especially under high context pressure. This middleware acts as a deterministic circuit breaker at the infrastructure level, ensuring that truncated code never touches your filesystem regardless of model behavior.

    Use cases

    • Building a custom Cursor-style IDE extension that needs reliable file writing.
    • Automating large-scale refactoring agents where manual verification is impossible.
    • Protecting continuous integration pipelines that use LLMs for automated bug fixes.
    • Developing multi-agent systems where sub-agents might otherwise pass truncated code to the next tool.

    Known limitations

    This is a streaming middleware layer for developers, not an end-user application. It remains dormant for markdown and prose, and it does not evaluate general code logic or quality.

    How to install

    Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

    ~30 seconds
    1. 1

      Download the ZIP

      Free skills download straight away. Paid skills unlock right after purchase.

    2. 2

      Unzip into your skills folder

      Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.

    3. 3

      Ask your agent to use it

      Restart the agent if it was already running. It picks the skill up automatically - no config needed.

    Skills folder by agent

    Click the path to copy it. Create the folder if it does not exist yet.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    30-day refund

    Not a fit? Get your money back

    Trust & safety

    Security scanned

    Verified clean today

    • Passed all security checks, Safe to install

    Needs access to

    Json Schema
    Github

    Listedtoday

    What's inside

    Frequently Asked Questions