Skip to content

Tayhlow8/Caixa-D-gua-website-2026 / .agents/skills/gstack

gstack

Flagged

Fast headless browser for QA testing and site dogfooding. Navigate pages, interact with elements, verify state, diff before/after, take annotated screenshots, test responsive layouts, forms, uploads, dialogs, and capture bug evidence. Use when asked to open or test a site, verify a deployment, dogfood a user flow, or file a bug with screenshots. (gstack)

FileKindSize
AGENTS.mdmarkdown2.5 KB
ARCHITECTURE.mdmarkdown29.3 KB
BROWSER.mdmarkdown29.2 KB
CHANGELOG.mdmarkdown389.3 KB
CLAUDE.mdmarkdown40.4 KB
CONTRIBUTING.mdmarkdown21.4 KB
DESIGN.mdmarkdown4.4 KB
ETHOS.mdmarkdown7.3 KB
LICENSEother1.0 KB
README.mdmarkdown37.3 KB
SKILL.mdskill md40.7 KB
SKILL.md.tmplother10.9 KB
TODOS.mdmarkdown79.0 KB
USING_GBRAIN_WITH_GSTACK.mdmarkdown19.0 KB
VERSIONother9 B
actionlint.yamlconfig56 B
agents/openai.yamlconfig351 B
bin/chrome-cdpother2.2 KB
bin/dev-setupother2.4 KB
bin/dev-teardownother1.6 KB
bin/gstack-analyticsother6.3 KB
bin/gstack-brain-consumerother5.5 KB
bin/gstack-brain-enqueueother1.9 KB
bin/gstack-brain-initother13.8 KB
bin/gstack-brain-readerother21 B
bin/gstack-brain-restoreother7.5 KB
bin/gstack-brain-syncother14.6 KB
bin/gstack-brain-uninstallother5.2 KB
bin/gstack-builder-profileother616 B
bin/gstack-codex-probeother4.5 KB
bin/gstack-community-dashboardother4.5 KB
bin/gstack-configother10.4 KB
bin/gstack-developer-profileother15.9 KB
bin/gstack-diff-scopeother3.1 KB
bin/gstack-extensionother2.0 KB
bin/gstack-gbrain-detectother3.6 KB
bin/gstack-gbrain-installother6.6 KB
bin/gstack-gbrain-lib.shscript3.4 KB
bin/gstack-gbrain-repo-policyother7.0 KB
bin/gstack-gbrain-supabase-provisionother15.2 KB
bin/gstack-gbrain-supabase-verifyother4.0 KB
bin/gstack-global-discover.tsscript18.8 KB
bin/gstack-jsonl-mergeother2.7 KB
bin/gstack-learnings-logother3.3 KB
bin/gstack-learnings-searchother4.8 KB
bin/gstack-model-benchmarkother5.8 KB
bin/gstack-next-versionother16.3 KB
bin/gstack-open-urlother338 B
bin/gstack-patch-namesother1.2 KB
bin/gstack-platform-detectother1.0 KB
bin/gstack-question-logother6.4 KB
bin/gstack-question-preferenceother9.4 KB
bin/gstack-relinkother3.0 KB
bin/gstack-repo-modeother3.5 KB
bin/gstack-review-logother866 B
bin/gstack-review-readother528 B
bin/gstack-security-dashboardother4.9 KB
bin/gstack-session-updateother3.5 KB
bin/gstack-settings-hookother2.8 KB
bin/gstack-slugother1.9 KB
bin/gstack-specialist-statsother2.2 KB
bin/gstack-taste-updateother10.5 KB
bin/gstack-team-initother6.7 KB
bin/gstack-telemetry-logother10.0 KB
bin/gstack-telemetry-syncother5.3 KB
bin/gstack-timeline-logother1.6 KB
bin/gstack-timeline-readother2.6 KB
bin/gstack-uninstallother10.3 KB
bin/gstack-update-checkother7.7 KB
bun.lockother57.4 KB
claude/SKILL.md.tmplother8.7 KB
conductor.jsonconfig87 B
connect-chromeother19 B
contrib/add-host/SKILL.md.tmplother1.7 KB
design/prototype.tsscript5.4 KB
design/src/auth.tsscript1.7 KB
design/src/brief.tsscript1.9 KB
design/src/check.tsscript3.3 KB
design/src/cli.tsscript8.9 KB
design/src/commands.tsscript3.0 KB
design/src/compare.tsscript19.1 KB
design/src/design-to-code.tsscript3.0 KB
design/src/diff.tsscript3.3 KB
design/src/evolve.tsscript5.3 KB
design/src/gallery.tsscript7.0 KB
design/src/generate.tsscript4.4 KB
design/src/iterate.tsscript6.5 KB
design/src/memory.tsscript6.0 KB
design/src/serve.tsscript8.3 KB
design/src/session.tsscript1.8 KB
design/src/variants.tsscript8.7 KB
design/test/feedback-roundtrip.test.tsscript12.6 KB
design/test/gallery.test.tsscript5.0 KB
design/test/serve.test.tsscript16.0 KB
docs/ADDING_A_HOST.mdmarkdown6.1 KB
docs/ON_THE_LOC_CONTROVERSY.mdmarkdown13.2 KB
docs/OPENCLAW.mdmarkdown6.5 KB
docs/REMOTE_BROWSER_ACCESS.mdmarkdown9.6 KB
docs/designs/BUN_NATIVE_INFERENCE.mdmarkdown6.7 KB
docs/designs/CHROME_VS_CHROMIUM_EXPLORATION.mdmarkdown4.0 KB
docs/designs/CONDUCTOR_CHROME_SIDEBAR_INTEGRATION.mdmarkdown3.5 KB
docs/designs/CONDUCTOR_SESSION_API.mdmarkdown3.9 KB
docs/designs/DESIGN_SHOTGUN.mdmarkdown22.5 KB
docs/designs/DESIGN_TOOLS_V1.mdmarkdown36.0 KB
docs/designs/GCOMPACTION.mdmarkdown57.6 KB
docs/designs/GSTACK_BROWSER_V0.mdmarkdown17.3 KB
docs/designs/ML_PROMPT_INJECTION_KILLER.mdmarkdown20.7 KB
docs/designs/PACING_UPDATES_V0.mdmarkdown9.7 KB
docs/designs/PLAN_TUNING_V0.mdmarkdown31.2 KB
docs/designs/PLAN_TUNING_V1.mdmarkdown19.0 KB
docs/designs/SELF_LEARNING_V0.mdmarkdown15.4 KB
docs/designs/SESSION_INTELLIGENCE.mdmarkdown6.8 KB
docs/designs/SIDEBAR_MESSAGE_FLOW.mdmarkdown10.1 KB
docs/designs/SLATE_HOST.mdmarkdown12.6 KB
docs/designs/SLOP_SCAN_FOR_REVIEW_SHIP.mdmarkdown3.0 KB
docs/evals/security-bench-ensemble-v2.jsonconfig1.6 KB
docs/gbrain-sync-errors.mdmarkdown6.2 KB
docs/gbrain-sync.mdmarkdown6.5 KB
docs/images/github-2013.pngbinary61.9 KB
docs/images/github-2026.pngbinary59.1 KB
docs/skills.mdmarkdown59.5 KB
extension/background.jsscript20.6 KB
extension/content.cssother2.5 KB
extension/content.jsscript11.9 KB
extension/icons/icon-128.pngbinary2.8 KB
extension/icons/icon-16.pngbinary400 B
extension/icons/icon-48.pngbinary1.1 KB
extension/inspector.cssother798 B
extension/inspector.jsscript15.7 KB
extension/lib/xterm-addon-fit.jsscript1.5 KB
extension/lib/xterm.cssother5.3 KB
extension/lib/xterm.jsscript276.8 KB
extension/manifest.jsonconfig783 B
extension/popup.htmlother2.3 KB
extension/popup.jsscript1.7 KB
extension/sidepanel-terminal.jsscript15.2 KB
extension/sidepanel.cssother39.6 KB
extension/sidepanel.htmlother9.1 KB
extension/sidepanel.jsscript40.2 KB
hosts/claude.tsscript1.1 KB
hosts/codex.tsscript2.2 KB
hosts/cursor.tsscript1.1 KB
hosts/factory.tsscript1.8 KB
hosts/gbrain.tsscript2.2 KB
hosts/hermes.tsscript2.1 KB
hosts/index.tsscript2.2 KB
hosts/kiro.tsscript1.2 KB
hosts/openclaw.tsscript2.0 KB
hosts/opencode.tsscript1.3 KB
hosts/slate.tsscript1.1 KB
lib/worktree.tsscript9.6 KB
model-overlays/claude.mdmarkdown613 B
model-overlays/gemini.mdmarkdown551 B
model-overlays/gpt-5.4.mdmarkdown683 B
model-overlays/gpt.mdmarkdown1.9 KB
model-overlays/o-series.mdmarkdown660 B
model-overlays/opus-4-7.mdmarkdown1.5 KB
openclaw/agents-gstack-section.mdmarkdown2.5 KB
openclaw/gstack-full-CLAUDE.mdmarkdown538 B
openclaw/gstack-lite-CLAUDE.mdmarkdown688 B
openclaw/gstack-plan-CLAUDE.mdmarkdown1.0 KB
package.jsonmanifest4.7 KB
scripts/analytics.tsscript5.3 KB
scripts/app/gstack-browserother2.4 KB
scripts/app/icon.icnsother1.0 MB
scripts/archetypes.tsscript5.4 KB
scripts/build-app.shscript7.5 KB
scripts/compare-pr-version.tsscript3.0 KB
scripts/detect-bump.tsscript1.2 KB
scripts/dev-skill.tsscript2.4 KB
scripts/discover-skills.tsscript1.2 KB
scripts/eval-compare.tsscript3.0 KB
scripts/eval-list.tsscript3.5 KB
scripts/eval-select.tsscript3.1 KB
scripts/eval-summary.tsscript6.5 KB
scripts/eval-watch.tsscript5.4 KB
scripts/garry-output-comparison.tsscript17.0 KB
scripts/gen-skill-docs.tsscript28.3 KB
scripts/host-adapters/openclaw-adapter.tsscript1.7 KB
scripts/host-config-export.tsscript3.4 KB
scripts/host-config.tsscript7.3 KB
scripts/jargon-list.jsonconfig1.8 KB
scripts/models.tsscript2.5 KB
scripts/one-way-doors.tsscript5.6 KB
scripts/preflight-agent-sdk.tsscript4.4 KB
scripts/psychographic-signals.tsscript10.3 KB
scripts/question-registry.tsscript23.5 KB
scripts/resolvers/browse.tsscript6.2 KB
scripts/resolvers/codex-helpers.tsscript5.0 KB
scripts/resolvers/composition.tsscript1.8 KB
scripts/resolvers/confidence.tsscript1.6 KB
scripts/resolvers/constants.tsscript3.1 KB
scripts/resolvers/design.tsscript56.9 KB
scripts/resolvers/dx.tsscript5.4 KB
scripts/resolvers/gbrain.tsscript5.3 KB
scripts/resolvers/index.tsscript4.3 KB
scripts/resolvers/learnings.tsscript3.9 KB
scripts/resolvers/make-pdf.tsscript2.2 KB
scripts/resolvers/model-overlay.tsscript2.2 KB
scripts/resolvers/preamble.tsscript5.7 KB

design/test/feedback-roundtrip.test.ts

View on GitHub
/**
 * End-to-end feedback round-trip test.
 *
 * This is THE test that proves "changes on the website propagate to the agent."
 * Tests the full pipeline:
 *
 *   Browser click → JS fetch() → HTTP POST → server writes file → agent polls file
 *
 * The Kitsune bug: agent backgrounded $D serve, couldn't read stdout, user
 * clicked Regenerate, board showed spinner, agent never saw the feedback.
 * Fix: server writes feedback-pending.json to disk. Agent polls for it.
 *
 * This test verifies every link in the chain.
 */

import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
import { BrowserManager } from '../../browse/src/browser-manager';
import { handleReadCommand } from '../../browse/src/read-commands';
import { handleWriteCommand } from '../../browse/src/write-commands';
import { generateCompareHtml } from '../src/compare';
import * as fs from 'fs';
import * as path from 'path';

let bm: BrowserManager;
let baseUrl: string;
let server: ReturnType<typeof Bun.serve>;
let tmpDir: string;
let boardHtmlPath: string;
let serverState: string;

function createTestPng(filePath: string): void {
  const png = Buffer.from(
    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/58BAwAI/AL+hc2rNAAAAABJRU5ErkJggg==',
    'base64'
  );
  fs.writeFileSync(filePath, png);
}

beforeAll(async () => {
  tmpDir = '/tmp/feedback-roundtrip-' + Date.now();
  fs.mkdirSync(tmpDir, { recursive: true });

  createTestPng(path.join(tmpDir, 'variant-A.png'));
  createTestPng(path.join(tmpDir, 'variant-B.png'));
  createTestPng(path.join(tmpDir, 'variant-C.png'));

  const html = generateCompareHtml([
    path.join(tmpDir, 'variant-A.png'),
    path.join(tmpDir, 'variant-B.png'),
    path.join(tmpDir, 'variant-C.png'),
  ]);
  boardHtmlPath = path.join(tmpDir, 'design-board.html');
  fs.writeFileSync(boardHtmlPath, html);

  serverState = 'serving';

  // This server mirrors the real serve.ts behavior:
  // - Injects __GSTACK_SERVER_URL into the HTML
  // - Handles POST /api/feedback with file writes
  // - Handles GET /api/progress for regeneration polling
  // - Handles POST /api/reload for board swapping
  let currentHtml = html;

  server = Bun.serve({
    port: 0,
    fetch(req) {
      const url = new URL(req.url);

      if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/index.html')) {
        const injected = currentHtml.replace(
          '</head>',
          `<script>window.__GSTACK_SERVER_URL = '${url.origin}';</script>\n</head>`
        );
        return new Response(injected, {
          headers: { 'Content-Type': 'text/html; charset=utf-8' },
        });
      }

      if (req.method === 'GET' && url.pathname === '/api/progress') {
        return Response.json({ status: serverState });
      }

      if (req.method === 'POST' && url.pathname === '/api/feedback') {
        return (async () => {
          let body: any;
          try { body = await req.json(); } catch {
            return Response.json({ error: 'Invalid JSON' }, { status: 400 });
          }
          if (typeof body !== 'object' || body === null) {
            return Response.json({ error: 'Expected JSON object' }, { status: 400 });
          }

          const isSubmit = body.regenerated === false;
          const feedbackFile = isSubmit ? 'feedback.json' : 'feedback-pending.json';
          fs.writeFileSync(path.join(tmpDir, feedbackFile), JSON.stringify(body, null, 2));

          if (isSubmit) {
            serverState = 'done';
            return Response.json({ received: true, action: 'submitted' });
          }
          serverState = 'regenerating';
          return Response.json({ received: true, action: 'regenerate' });
        })();
      }

      if (req.method === 'POST' && url.pathname === '/api/reload') {
        return (async () => {
          const body = await req.json();
          if (body.html && fs.existsSync(body.html)) {
            currentHtml = fs.readFileSync(body.html, 'utf-8');
            serverState = 'serving';
            return Response.json({ reloaded: true });
          }
          return Response.json({ error: 'Not found' }, { status: 400 });
        })();
      }

      return new Response('Not found', { status: 404 });
    },
  });

  baseUrl = `http://localhost:${server.port}`;

  bm = new BrowserManager();
  await bm.launch();
});

afterAll(() => {
  try { server.stop(); } catch {}
  fs.rmSync(tmpDir, { recursive: true, force: true });
  setTimeout(() => process.exit(0), 500);
});

// ─── The critical test: browser click → file on disk ─────────────

describe('Submit: browser click → feedback.json on disk', () => {
  test('clicking Submit writes feedback.json that the agent can poll for', async () => {
    // Clean up any prior files
    const feedbackPath = path.join(tmpDir, 'feedback.json');
    if (fs.existsSync(feedbackPath)) fs.unlinkSync(feedbackPath);
    serverState = 'serving';

    // Navigate to the board (served with __GSTACK_SERVER_URL injected)
    await handleWriteCommand('goto', [baseUrl], bm);

    // Verify __GSTACK_SERVER_URL was injected
    const hasServerUrl = await handleReadCommand('js', [
      '!!window.__GSTACK_SERVER_URL'
    ], bm);
    expect(hasServerUrl).toBe('true');

    // User picks variant A, rates it 5 stars
    await handleReadCommand('js', [
      'document.querySelectorAll("input[name=\\"preferred\\"]")[0].click()'
    ], bm);
    await handleReadCommand('js', [
      'document.querySelectorAll(".stars")[0].querySelectorAll(".star")[4].click()'
    ], bm);

    // User adds overall feedback
    await handleReadCommand('js', [
      'document.getElementById("overall-feedback").value = "Ship variant A"'
    ], bm);

    // User clicks Submit
    await handleReadCommand('js', [
      'document.getElementById("submit-btn").click()'
    ], bm);

    // Wait a beat for the async POST to complete
    await new Promise(r => setTimeout(r, 300));

    // THE CRITICAL ASSERTION: feedback.json exists on disk
    expect(fs.existsSync(feedbackPath)).toBe(true);

    // Agent reads it (simulating the polling loop)
    const feedback = JSON.parse(fs.readFileSync(feedbackPath, 'utf-8'));
    expect(feedback.preferred).toBe('A');
    expect(feedback.ratings.A).toBe(5);
    expect(feedback.overall).toBe('Ship variant A');
    expect(feedback.regenerated).toBe(false);
  });

  test('post-submit: inputs disabled, success message shown', async () => {
    // Wait for the async .then() callback to update the DOM
    // (the file write is instant but the fetch().then() in the browser is async)
    await new Promise(r => setTimeout(r, 500));

    // After submit, the page should be read-only
    const submitBtnExists = await handleReadCommand('js', [
      'document.getElementById("submit-btn").style.display'
    ], bm);
    // submit button is hidden after post-submit lifecycle
    expect(submitBtnExists).toBe('none');

    const successVisible = await handleReadCommand('js', [
      'document.getElementById("success-msg").style.display'
    ], bm);
    expect(successVisible).toBe('block');

    // Success message should mention /design-shotgun
    const successText = await handleReadCommand('js', [
      'document.getElementById("success-msg").textContent'
    ], bm);
    expect(successText).toContain('design-shotgun');
  });
});

describe('Regenerate: browser click → feedback-pending.json on disk', () => {
  test('clicking Regenerate writes feedback-pending.json that the agent can poll for', async () => {
    // Clean up
    const pendingPath = path.join(tmpDir, 'feedback-pending.json');
    if (fs.existsSync(pendingPath)) fs.unlinkSync(pendingPath);
    serverState = 'serving';

    // Fresh page
    await handleWriteCommand('goto', [baseUrl], bm);

    // User clicks "Totally different" chiclet
    await handleReadCommand('js', [
      'document.querySelector(".regen-chiclet[data-action=\\"different\\"]").click()'
    ], bm);

    // User clicks Regenerate
    await handleReadCommand('js', [
      'document.getElementById("regen-btn").click()'
    ], bm);

    // Wait for async POST
    await new Promise(r => setTimeout(r, 300));

    // THE CRITICAL ASSERTION: feedback-pending.json exists on disk
    expect(fs.existsSync(pendingPath)).toBe(true);

    // Agent reads it
    const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
    expect(pending.regenerated).toBe(true);
    expect(pending.regenerateAction).toBe('different');

    // Agent would delete it and act on it
    fs.unlinkSync(pendingPath);
    expect(fs.existsSync(pendingPath)).toBe(false);
  });

  test('"More like this" writes feedback-pending.json with variant reference', async () => {
    const pendingPath = path.join(tmpDir, 'feedback-pending.json');
    if (fs.existsSync(pendingPath)) fs.unlinkSync(pendingPath);
    serverState = 'serving';

    await handleWriteCommand('goto', [baseUrl], bm);

    // Click "More like this" on variant B (index 1)
    await handleReadCommand('js', [
      'document.querySelectorAll(".more-like-this")[1].click()'
    ], bm);

    await new Promise(r => setTimeout(r, 300));

    expect(fs.existsSync(pendingPath)).toBe(true);
    const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
    expect(pending.regenerated).toBe(true);
    expect(pending.regenerateAction).toBe('more_like_B');

    fs.unlinkSync(pendingPath);
  });

  test('board shows spinner after regenerate (user stays on same tab)', async () => {
    serverState = 'serving';
    await handleWriteCommand('goto', [baseUrl], bm);

    await handleReadCommand('js', [
      'document.querySelector(".regen-chiclet[data-action=\\"different\\"]").click()'
    ], bm);
    await handleReadCommand('js', [
      'document.getElementById("regen-btn").click()'
    ], bm);

    await new Promise(r => setTimeout(r, 300));

    // Board should show "Generating new designs..." text
    const bodyText = await handleReadCommand('js', [
      'document.body.textContent'
    ], bm);
    expect(bodyText).toContain('Generating new designs');
  });
});

describe('Full regeneration round-trip: regen → reload → submit', () => {
  test('agent can reload board after regeneration, user submits on round 2', async () => {
    // Clean start
    const pendingPath = path.join(tmpDir, 'feedback-pending.json');
    const feedbackPath = path.join(tmpDir, 'feedback.json');
    if (fs.existsSync(pendingPath)) fs.unlinkSync(pendingPath);
    if (fs.existsSync(feedbackPath)) fs.unlinkSync(feedbackPath);
    serverState = 'serving';

    await handleWriteCommand('goto', [baseUrl], bm);

    // Step 1: User clicks Regenerate
    await handleReadCommand('js', [
      'document.querySelector(".regen-chiclet[data-action=\\"match\\"]").click()'
    ], bm);
    await handleReadCommand('js', [
      'document.getElementById("regen-btn").click()'
    ], bm);

    await new Promise(r => setTimeout(r, 300));

    // Agent polls and finds feedback-pending.json
    expect(fs.existsSync(pendingPath)).toBe(true);
    const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
    expect(pending.regenerateAction).toBe('match');
    fs.unlinkSync(pendingPath);

    // Step 2: Agent generates new variants and creates a new board
    const newBoardPath = path.join(tmpDir, 'design-board-v2.html');
    const newHtml = generateCompareHtml([
      path.join(tmpDir, 'variant-A.png'),
      path.join(tmpDir, 'variant-B.png'),
      path.join(tmpDir, 'variant-C.png'),
    ]);
    fs.writeFileSync(newBoardPath, newHtml);

    // Step 3: Agent POSTs /api/reload to swap the board
    const reloadRes = await fetch(`${baseUrl}/api/reload`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ html: newBoardPath }),
    });
    const reloadData = await reloadRes.json();
    expect(reloadData.reloaded).toBe(true);
    expect(serverState).toBe('serving');

    // Step 4: Board auto-refreshes (simulated by navigating again)
    await handleWriteCommand('goto', [baseUrl], bm);

    // Verify the board is fresh (no prior picks)
    const status = await handleReadCommand('js', [
      'document.getElementById("status").textContent'
    ], bm);
    expect(status).toBe('');

    // Step 5: User picks variant C on round 2 and submits
    await handleReadCommand('js', [
      'document.querySelectorAll("input[name=\\"preferred\\"]")[2].click()'
    ], bm);
    await handleReadCommand('js', [
      'document.getElementById("submit-btn").click()'
    ], bm);

    await new Promise(r => setTimeout(r, 300));

    // Agent polls and finds feedback.json (submit = final)
    expect(fs.existsSync(feedbackPath)).toBe(true);
    const final = JSON.parse(fs.readFileSync(feedbackPath, 'utf-8'));
    expect(final.preferred).toBe('C');
    expect(final.regenerated).toBe(false);
  });
});
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall