ax dx

    1

    Make code equally legible to humans and AI agents, with verified claims, not just comments.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    ax-dx

    Example session with this skill installed

    /ax-dx src/auth.ts - check this for AX/DX compliance and verify the session validation claims.

    • Read your context and instructions
    • Compiled the ax-dx

    I have completed the AX/DX audit of `src/auth.ts`. I scanned the session validation logic, checked existing docstrings against the implementation, and applied the triage rubric defined in the rules. ## AX/DX Audit Report: src/auth.ts | Component | Triage Tier | AX-Status | Findings | | :--- | :--- | :--- | :--- | | `validateSession` | Tier 1 (High) | `AX-UNVERIFIED` | Docstring claims it "checks expiry and DB state," but implementation only checks JWT expiry locally. | | `clearAuthCookie` | Tier 2 (Med) | `AX-VERIFIED` | Implementation correctly handles both Secure and HttpOnly flags as documented. | | `UserInterface` | Tier 0 (Low) | `N/A` | Simple data structure; no verification required per triage rules. | | `refreshTokens` | Tier 1 (High) | `AX-UNVERIFIED` | Potential side effect: updates `last_login` timestamp in DB, which is not mentioned in the documentation. | ### Logic Discrepancy Detail The function `validateSession` is currently misleading for agents. It claims to verify the database state, which would lead an agent to assume a network call is made. However, the code strictly performs a cryptographic check on the token string. This mismatch is a high-risk AX failure. **Next steps** - Update the `validateSession` docstring to reflect that it is a local-only check to prevent agent logic errors. - Explicitly document the `last_login` side effect in `refreshTokens` using the `AX-VERIFIED` tag. - Re-run `/ax-dx` after updates to confirm the audit passes.

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

    About this skill

    "ax-dx" makes code equally legible to the human maintaining it and the AI agent modifying it next. Instead of adding more comments, it treats documentation claims as evidence that must be verified against the actual implementation - turning docstrings into trustworthy signals an agent can act on. Two modes: - Passive mode runs implicitly while you write, edit, or review code. Triages each unit (Tier 0/1/2), tags verified claims with AX-VERIFIED, and flags unverifiable ones as AX-UNVERIFIED rather than silently rewriting them. - Active mode (/ax-dx or /ax-dx [path]) produces a read-only audit report of a codebase, folder, or file — classified units, verified and unverified claims, concealed side effects, and files needing deeper attention. Portable across 8 coding agents: Claude Code, Codex, Cursor, OpenCode, Antigravity, Kiro, and others. One canonical rule set under rules/, thin adapters per agent (SKILL.md, AGENTS.md, .cursor/rules, .agent/, .kiro/steering). Core principle: evidence over authority. A claim isn't true because it's written confidently - it's true when something concrete establishes it. Created by M V Abhiram (@Tusm11). MIT licensed. Source and issues: https://github.com/Tusm11/skill-axdx

    Active mode is read-only and will not modify code. Requires clear triage levels; Tier 0 code receives no documentation or tags. Verification context is limited to visible file scope.

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

    • Free with an Agensi account

    Requires

    None

    Permissions

    Read Files
    Write Files

    File Scopes

    **/*

    ax-dx reads source files to classify them (triage) and writes verification tags (AX-VERIFIED / AX-UNVERIFIED) as comments or docstrings in Tier 1/2 code. Active mode (/ax-dx) is strictly read-only and produces a report without modifying files. No shell, network, or environment access needed.

    Listed29 days ago

    What's inside

    Frequently Asked Questions

    This skill addresses the 'hallucination loop' where AI agents misinterpret vague or outdated docstrings, leading to broken code. It ensures that your documentation serves both human developers (DX) and AI agents (AX) by verifying that comments actually match the underlying logic.

    ax-dx is language-agnostic and compatible with any IDE or AI coding assistant, such as Cursor, Claude Code, or GitHub Copilot. It works by utilizing standard commenting conventions and machine-readable tags that any LLM-based agent can interpret.

    The skill uses a tiered triage rubric to categorize code by impact, only requiring deep verification for high-risk logic. This prevents 'documentation bloat' by keeping simple code idiomatic and clean for humans while focusing rigor where AI agents are most likely to fail.

    You will receive the full ax-dx skill set, including the dual-audience verification rubric, the triage enforcement logic, and the AX-tagging system. It also includes instructions for integrating the `/ax-dx` audit command into your existing development workflow or CI/CD pipeline.

    ax-dx operates primarily in a diagnostic and tagging capacity; it does not unilaterally rewrite your functional logic. When it detects a discrepancy (marked as AX-UNVERIFIED), it flags the issue for human review to ensure your code's integrity remains under your control.

    No. The triage system classifies most code as Tier 0 (trivial / already obvious) and leaves it untouched. Only Tier 1 and Tier 2 code: public APIs, shared state, non-obvious invariants, receive verified claim tags. The explicit goal is less documentation, higher signal.

    It gets tagged AX-UNVERIFIED and surfaced to the human reviewer. ax-dx never silently rewrites an unverifiable claim, since the original author may have intent the skill can’t see.

    Yes. The canonical rules live in rules/, with thin adapters for Cursor, Antigravity, Kiro, and anything that reads AGENTS.md or SKILL.md. The behavior is identical across runtimes.

    New in Code Quality & Review