More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Agent Build Discipline

    1

    Every session ends by writing one thing down: what was touched, one lesson, what is next.

    $14.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Agent Build Discipline

    Agent Build Discipline

    Example session with this skill installed

    An agent declares 'build-auth' complete with no evidence — the verifier rejects it (exit 1). After writing tests/auth.test.ts and docs/plan.md and citing them in the envelope: CONTRACT VERIFIED (pass, 2 evidence paths), phase may close.

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

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

    About this skill

    AI agents don't fail because they lack skill — they fail because they lack disipline: they arrive remembering nothing, skip stages, declare "done" without evidence, and drop a 4,000-line PR on a reviewer at midnight.

    This skill unifies five gates into one operating loop, the same loop that shipped a real healthcare app through months of agent-driven development:

    Every session starts by reading its own past: the project plan, the last session trace, the open risk items. Every session ends by writing one thing down: what was touched, one lesson, what is next. No zero-sum sessions.

    • The plan checklist in the repo is the single source of truth (not chat scrollback, not a dashboard of vibes).
    • Sessions are named (costing one line of focus) so any future reader can tell who-did-what-and-when.
    • Leave-a-trace rule: every touched file group is recorded, so the next arrival resumes instead of re-exploring.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    This is discipline, not magic: it cannot stop an agent writing bad code, it makes bad process visible in seconds. Gates are file-based counts, not judgment. The verifier checks file existence, evidence, and envelope shape — not semantic correctness of the work.

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

    Software
    Python 3.8+

    Python runs the contract verifier with the standard library; nothing to install.

    Permissions

    Read Files
    Write Files

    File Scopes

    the
    verifier
    reads
    contract
    JSON
    and
    evidence
    paths
    it
    cites
    (that
    is
    its
    job)
    writes
    nothing;
    discipline
    files
    live
    wherever
    you
    copy
    them
    (suggested
    ops/discipline/)

    Purpose: enforce a build discipline for AGENT-driven development — session anchors, phase gates, result contracts, TDD, and PR risk gating. check_contract.py is pure Python stdlib: it validates the contract envelope format and confirms every cited evidence path exists on disk. No network connections, no command execution inside the verifier, no access to environment variables or credentials. All other artifacts are plain Markdown/JSON templates the agent fills per project.

    Listed16 days ago
    Updated7 days ago

    What's inside

    Frequently Asked Questions

    Five disconnected practices decay separately; one loop reinforces itself. The same session that leaves a trace reads it on arrival, the same contract the gate refuses is the one the verifier confirms, and the risk gate sees the delta the TDD gate just produced.

    It was forged and proven in agent-driven development (where agents skip stages and declare verbal 'done'), but the loop works for any solo or small-team workflow that needs provable 'done' and review-worthy deltas.

    No. Everything is local files: one JSON envelope per phase, one verifier script, one Markdown declaration of phases and risk caps. Readable in any diff, auditable by any reviewer.

    Missing envelope fields, invalid status, a 'pass' with no evidence paths, and any cited evidence path that does not exist on disk. Rejections print the exact list of lies — fix the work, not the verifier.

    New in LLM Ops