Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    agent ops discipline

    1

    Operational rules for AI agents to prevent redundant builds, manage token costs, and maintain clean project state.

    Free

    1 useSecurity scanned
    agent ops discipline

    agent ops discipline

    Example session with this skill installed

    I need to update the project's dependency list in the docs and then refactor the logging utility. Start by checking if we have a script for the doc update.

    • Read your context and instructions
    • Compiled the agent ops discipline

    I have completed the audit of existing tooling and the dependency documentation update. I am now prepared to route the refactoring task.

    Agent Ops Audit & Action Log

    CategoryFinding / ActionStatus
    Tool SearchChecked package.json and scripts/. Found npm run docs:generate.Found Existing
    Doc UpdateExecuted docs:generate. Verified new dependency counts in DEPENDENCIES.md.Verified
    TrackingUpdated Issue #442: Added reading "42 dependencies" dated 2023-10-24.Updated
    Model RoutingRefactoring logging utility: Routing to Mid Model (Standard Implementation).Routed
    CleanupTerminated background doc-server process (PID 4902).Clean

    Refactoring Brief for Subagent:

    • Area: src/utils/logger.ts and src/types/log-levels.d.ts.
    • Done when: npm test passes and no instances of console.log remain in src/.
    • Model: Claude 3 Haiku (Mechanical Edit).
    • Cleanup: Delete branch fix/logging-cleanup after merge.

    Next steps

    1. Review the proposed subagent brief for the logging refactor.
    2. Approve the merge of the dependency doc updates to main.
    3. Confirm if the "High" priority on Issue #442 should remain active after the refactor.

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

    About this skill

    Long-running AI coding agents often drift into inefficiency, creating redundant tools, letting documentation rot, or burning through token budgets on trivial tasks. This skill enforces a rigorous operational discipline for agents working on complex, multi-week projects. It provides a framework for resource management, task hygiene, and cross-model routing to ensure your agent acts like a senior engineer rather than a runaway script.

    What it does

    • Redundancy prevention mandates checking existing package.json scripts, Makefiles, and tool directories before any new code is proposed.
    • Stale-data protection prohibits hardcoding values in documentation, requiring generated numbers or tests that fail when data drifts.
    • Token cost optimization routes work to the cheapest capable model based on the specific deliverable rather than file complexity.
    • Tracker integrity enforces aggressive ticket management, ensuring task statuses, assignments, and descriptions reflect the actual state of play.
    • Environment cleanup ensures all background processes, dev servers, and temporary git branches are purged immediately upon task completion.

    How it works

    1. Pre-flight check: Before building a new feature or tool, the agent scans the project index and synonyms to verify the capability doesn't already exist.
    2. Model routing: The agent evaluates whether a task is mechanical, implementation-heavy, or architectural to select the appropriate model tier.
    3. Execution & brief: Subagents are dispatched with tight, scoped briefs that include explicit "done when" conditions and cleanup rules.
    4. Finalization: Once verified, the agent merges code, deletes the local and remote branches, and closes the associated tracker ticket.

    Frameworks & tools

    This skill is platform-agnostic but designed to interface with Git, task trackers like GitHub Issues, Linear, or Jira, and various LLM tiers (small, mid, and top-tier reasoning models).

    Why this beats prompting it yourself

    Generic prompts often fail to address the "hidden costs" of agentic workflows, such as orphan background processes or context window bloat from stale instruction files. This skill codifies specific operational failures learned from months of real-world production use, preventing expensive re-work and human-interruption cycles.

    Use cases

    • Managing a complex refactor across multiple PRs without leaving stale branches.
    • Keeping a project README updated with real build metrics and test counts.
    • Orchestrating a team of subagents to handle routine mechanical edits at low cost.
    • Maintaining a clean Linear or GitHub project board during high-velocity development.

    Known limitations

    Does not provide automated integration with specific tracker APIs; the agent must have its own tools to interact with Jira or Linear. It cannot prevent a human from manually overriding its cleanup rules.

    Requires agent access to project trackers and git tools. Cannot prevent human-induced status drift. Effectiveness depends on the agent's ability to browse local scripts and config files.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    These are working rules, not a tool. The skill installs nothing and calls no services. It shapes how your agent searches before building, writes docs, updates your tracker and cleans up after itself, using the file, terminal and git access your agent already has. It never pushes, deletes a branch someone else is using, or closes a ticket waiting on you.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    The skill prevents "agent drift" by enforcing rigorous checks for existing tools and scripts before writing new code, ensuring your project doesn't become cluttered with redundant or conflicting files.

    It utilizes a classification logic that matches task types—such as mechanical edits vs. architectural design—to the most cost-effective LLM tier, preventing top-tier model spending on low-complexity work.

    Yes, the skill is platform-agnostic and designed to interface with any agent that has existing tool access to Git, GitHub Issues, Linear, or Jira.

    You receive the operational framework, the logic for pre-flight checks and model routing, and the standardized "done when" criteria for subagent task briefs.

    While it automates cleanup for branches and processes, the skill cannot prevent manual human overrides, nor does it provide the underlying API connections for your trackers.

    New in Agents & Orchestration