Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+22 more

    graybeard

    1

    Staff-engineer judgment for AI coding agents: understand first, make the smallest correct change, verify with evidence, and report concisely.

    Free

    Security scanned
    graybeard

    graybeard

    Example session with this skill installed

    Fix the bug where the user session doesn't clear on logout in the Express app. Keep it minimal and follow existing patterns.

    • Read your context and instructions
    • Compiled the graybeard

    Summary

    Fixed the logout flow so the server destroys the session and clears the existing session cookie using the same cookie configuration already used by the application.

    Change

    router.post('/logout', (req, res) => {
      req.session.destroy((err) => {
        if (err) {
          console.error('Logout error:', err);
          return res.status(500).send('Could not log out');
        }
    
        res.clearCookie('sid', {
          path: '/',
          httpOnly: true,
          secure: process.env.NODE_ENV === 'production'
        });
    
        return res.status(200).json({ status: 'success' });
      });
    });
    

    Verification

    • Checked the existing login/logout cookie configuration before changing it.
    • Confirmed the change is limited to the logout flow.
    • Verified that the response clears the sid cookie with the existing path and security settings.
    • No new dependency or abstraction was introduced.

    Result

    The logout path now destroys the server-side session and removes the client-side session cookie while preserving the application's existing conventions.

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

    About this skill

    Graybeard

    Make AI coding agents behave more like careful staff engineers.

    Graybeard applies a verification-driven engineering workflow to coding tasks: understand the existing code before editing, reuse what already exists, make the smallest change that fully solves the problem, verify the result with evidence, and report only what matters.

    It optimizes for correctness first, then maintainability, reviewer time, operational risk, and token usage.

    What it does

    • Understand before editing: Reads the relevant code and traces the real flow before making changes.
    • Match existing patterns: Finds an existing example and follows the codebase's naming, layering, and error-handling conventions.
    • Minimize the diff: Changes only what the task requires and avoids drive-by refactors, renames, and reformatting.
    • Reuse before adding: Checks repository code, platform features, standard libraries, and existing dependencies before introducing new code or dependencies.
    • Scale verification to risk: Uses lightweight checks for small changes and deeper verification for security, data, public API, and other high-impact changes.
    • Verify with evidence: Runs tests, builds, linters, or the relevant code path instead of assuming the change works.
    • Report concisely: Explains what changed and what was verified without unnecessary narration.

    How it works

    1. Understand: Read the relevant sections and trace the code path affected by the task.
    2. Decide: Identify the safest existing solution and consider what could break.
    3. Build: Implement the shortest correct solution using the existing architecture.
    4. Verify: Run an appropriate test, build, linter, or code path and review the resulting diff.
    5. Report: Give a concise summary of the change and verification, with additional detail only when an assumption or trade-off matters.

    Use cases

    • Fixing bugs without unnecessary rewrites.
    • Refactoring existing code while preserving architectural conventions.
    • Modifying shared utilities and public APIs carefully.
    • Working in unfamiliar or legacy codebases.
    • Making security- or data-sensitive changes with appropriate verification.
    • Keeping AI-generated pull requests focused and reviewable.

    Compatibility

    Graybeard is language- and framework-agnostic. It works with codebases ranging from legacy monoliths to modern services, provided the agent can read and modify the relevant repository files.

    Philosophy

    The goal is not to write the most sophisticated solution.

    The goal is to make the smallest correct change that fits the codebase, then prove that it works.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scanned

    Verified clean 3 days ago

    • Free to download with an account

    Listed3 days ago

    What's inside

    Frequently Asked Questions