Skip to content

vercel-labs/agent-skills / skills/vercel-optimize

vercel-optimize

Verified

Use for Vercel cost and performance optimization on deployed projects, especially Next.js, SvelteKit, Nuxt, and limited Astro apps. Collect Vercel metrics, usage, project config, and code scan results first; investigate only metric-backed candidates; produce ranked recommendations grounded in verified files and version-aware Vercel/framework docs. Trigger for Vercel bill reduction, slow or expensive routes, caching opportunities, Function Invocations, Build Minutes, Fast Data Transfer, Core Web Vitals, Bot Management, Fluid compute, or cost breakdown requests.

FileKindSize
AGENTS.mdmarkdown1.9 KB
CONTRIBUTING.mdmarkdown2.2 KB
README.mdmarkdown4.4 KB
SKILL.mdskill md16.9 KB
lib/auth-route.mjsscript807 B
lib/budget-summary.mjsscript7.0 KB
lib/citations.mjsscript3.9 KB
lib/cost-coverage.mjsscript8.4 KB
lib/dedup-recs.mjsscript9.9 KB
lib/deep-dive.mjsscript10.2 KB
lib/display-labels.mjsscript7.4 KB
lib/extract-claims.mjsscript18.7 KB
lib/framework-support.mjsscript2.1 KB
lib/gates/build-minutes-fanout.mjsscript2.9 KB
lib/gates/cold-start.mjsscript2.7 KB
lib/gates/contract.mjsscript3.1 KB
lib/gates/cwv-poor.mjsscript3.3 KB
lib/gates/external-api-slow.mjsscript2.1 KB
lib/gates/hard-gates.mjsscript2.5 KB
lib/gates/index.mjsscript2.0 KB
lib/gates/isr-overrevalidation.mjsscript2.4 KB
lib/gates/middleware-heavy.mjsscript2.0 KB
lib/gates/observability-events-attribution.mjsscript2.2 KB
lib/gates/platform-bot-protection.mjsscript5.0 KB
lib/gates/platform-fluid-compute.mjsscript3.5 KB
lib/gates/region-misconfig.mjsscript3.0 KB
lib/gates/route-errors.mjsscript3.0 KB
lib/gates/scanner-driven.mjsscript5.1 KB
lib/gates/select-candidates.mjsscript4.6 KB
lib/gates/slow-route.mjsscript4.3 KB
lib/gates/types.d.tsscript893 B
lib/gates/uncached-route.mjsscript3.9 KB
lib/gates/usage-spike-triage.mjsscript5.0 KB
lib/grade-recommendation.mjsscript6.7 KB
lib/impact-label.mjsscript5.2 KB
lib/impact-magnitude.mjsscript2.1 KB
lib/investigation-brief.mjsscript34.3 KB
lib/observation-safety.mjsscript9.3 KB
lib/project-facts.mjsscript4.3 KB
lib/queries.mjsscript10.1 KB
lib/reconcile-candidates.mjsscript15.6 KB
lib/render-report.mjsscript38.2 KB
lib/repo-root.mjsscript3.1 KB
lib/route-normalize.mjsscript8.4 KB
lib/sanitizers/bot-protection-certainty.mjsscript1.9 KB
lib/sanitizers/cache-tag-invalidation-certainty.mjsscript1.5 KB
lib/sanitizers/count-correct.mjsscript1.9 KB
lib/sanitizers/function-duration-invocations.mjsscript1.4 KB
lib/sanitizers/index.mjsscript3.0 KB
lib/sanitizers/middleware-conflict.mjsscript1.5 KB
lib/sanitizers/missing-citation.mjsscript497 B
lib/sanitizers/pre-release.mjsscript2.2 KB
lib/sanitizers/rate-limit.mjsscript2.6 KB
lib/sanitizers/rendering-mode-mislabel.mjsscript1.6 KB
lib/sanitizers/undeclared-dep.mjsscript2.8 KB
lib/sanitizers/vercel-directive-strip.mjsscript1.4 KB
lib/sanitizers/window-units.mjsscript869 B
lib/scanners/cache-components-suspense-dedupe.mjsscript4.3 KB
lib/scanners/edge-heavy-import.mjsscript3.7 KB
lib/scanners/force-dynamic.mjsscript1.5 KB
lib/scanners/headers-in-page.mjsscript1.5 KB
lib/scanners/index.mjsscript1.4 KB
lib/scanners/large-static-asset.mjsscript3.2 KB
lib/scanners/max-age-without-s-maxage.mjsscript1.6 KB
lib/scanners/middleware-broad-matcher.mjsscript1.9 KB
lib/scanners/missing-cache-headers.mjsscript3.8 KB
lib/scanners/prisma-include-tree.mjsscript1.5 KB
lib/scanners/region-pin-in-config.mjsscript3.4 KB
lib/scanners/source-maps-production.mjsscript1.3 KB
lib/scanners/sveltekit-prerender-missing.mjsscript2.1 KB
lib/scanners/turbo-force-bypass.mjsscript4.9 KB
lib/scanners/unoptimized-image.mjsscript4.4 KB
lib/scanners/use-cache-date-stamp.mjsscript3.9 KB
lib/support-topics.mjsscript12.5 KB
lib/throttle.mjsscript8.8 KB
lib/util.mjsscript544 B
lib/vercel.mjsscript30.4 KB
lib/verify-claim.mjsscript59.6 KB
lib/workspace-resolver.mjsscript17.1 KB
metadata.jsonconfig903 B
references/candidates.mdmarkdown8.3 KB
references/data-collection.mdmarkdown20.4 KB
references/docs-library.jsonconfig30.8 KB
references/doctrine.mdmarkdown9.3 KB
references/observability-plus.mdmarkdown5.2 KB
references/playbooks/README.mdmarkdown2.7 KB
references/playbooks/ai-application.mdmarkdown3.8 KB
references/playbooks/api-service.mdmarkdown2.4 KB
references/playbooks/content-site.mdmarkdown2.4 KB
references/playbooks/ecommerce.mdmarkdown2.7 KB
references/playbooks/marketing.mdmarkdown2.6 KB
references/playbooks/saas.mdmarkdown2.8 KB
references/playbooks/sveltekit.mdmarkdown3.9 KB
references/recommendations.mdmarkdown10.5 KB
references/scanner-patterns.mdmarkdown13.4 KB
references/scoring.mdmarkdown12.2 KB
references/support-topics/README.mdmarkdown1.7 KB
references/support-topics/astro-edge-middleware-scope.mdmarkdown1012 B
references/support-topics/astro-output-mode-and-isr.mdmarkdown1.1 KB
references/support-topics/auth-preserving-parallelization.mdmarkdown1.2 KB
references/support-topics/bot-protection-product-guardrails.mdmarkdown1.1 KB
references/support-topics/build-minutes-monorepo-fanout.mdmarkdown1.2 KB
references/support-topics/cache-components-static-shell-boundaries.mdmarkdown1.1 KB
references/support-topics/cache-components-suspense-dedupe-pitfall.mdmarkdown1.3 KB
references/support-topics/cdn-cache-auth-safety.mdmarkdown1.0 KB
references/support-topics/cold-start-initialization-bundle.mdmarkdown1.1 KB
references/support-topics/core-web-vitals-client-bottlenecks.mdmarkdown1.0 KB
references/support-topics/database-egress-pooling-region.mdmarkdown1015 B
references/support-topics/dynamic-rendering-traps.mdmarkdown1.1 KB
references/support-topics/external-api-critical-path-platform.mdmarkdown1.1 KB
references/support-topics/external-api-critical-path.mdmarkdown978 B
references/support-topics/fast-data-transfer-payloads.mdmarkdown1.0 KB
references/support-topics/fluid-compute-caveats.mdmarkdown1.1 KB
references/support-topics/function-duration-io-and-after.mdmarkdown1.0 KB
references/support-topics/function-invocation-reduction.mdmarkdown1.2 KB
references/support-topics/function-region-misconfiguration-ttfb.mdmarkdown1.2 KB
references/support-topics/image-optimization-cost-control.mdmarkdown1.0 KB
references/support-topics/isr-revalidation-static-generation.mdmarkdown1.4 KB
references/support-topics/middleware-proxy-edge-cost.mdmarkdown991 B
references/support-topics/next-fetch-revalidate-floor.mdmarkdown1.0 KB
references/support-topics/next-font-cls-self-hosting.mdmarkdown906 B
references/support-topics/next-heavy-ui-lazy-load-boundaries.mdmarkdown1.0 KB
references/support-topics/next-image-lcp-preload-sizes.mdmarkdown1.0 KB
references/support-topics/next-route-handler-get-cache-defaults.mdmarkdown1.0 KB
references/support-topics/next-script-third-party-strategy.mdmarkdown1.0 KB
references/support-topics/nextjs-version-cache-semantics.mdmarkdown996 B
references/support-topics/not-found-catchall-request-waste.mdmarkdown1.2 KB
references/support-topics/nuxt-route-rules-cache-isr.mdmarkdown1.2 KB
references/support-topics/observability-events-cost-attribution.mdmarkdown1.1 KB
references/support-topics/post-response-work-waituntil.mdmarkdown1009 B
references/support-topics/route-error-durable-offload.mdmarkdown1.3 KB
references/support-topics/route-error-runtime-limits.mdmarkdown988 B
references/support-topics/runtime-cache-reusable-data.mdmarkdown1.2 KB
references/support-topics/sveltekit-isr-prerender-safety.mdmarkdown1.1 KB
references/support-topics/sveltekit-split-cold-start-tradeoff.mdmarkdown1.0 KB
references/support-topics/usage-spike-triage.mdmarkdown1018 B
references/support-topics/use-cache-date-stamp-isr-write-amplifier.mdmarkdown1.2 KB
references/support-topics/use-cache-remote-shared-origin-data.mdmarkdown1.1 KB
references/support-topics/workflow-resumable-stream-routes.mdmarkdown1.2 KB
references/verification.mdmarkdown8.8 KB
references/voice.mdmarkdown3.6 KB
scripts/budget-summary.mjsscript2.0 KB
scripts/build-docs.mjsexecutablescript3.3 KB
scripts/check-citations.mjsscript3.4 KB
scripts/check-docs-fresh.mjsexecutablescript3.8 KB
scripts/collect-signals.mjsexecutablescript21.1 KB
scripts/collect-sub-agent-outputs.mjsscript9.9 KB
scripts/deep-dive.mjsexecutablescript12.0 KB
scripts/gate-investigations.mjsexecutablescript6.2 KB
scripts/merge-signals.mjsscript6.2 KB
scripts/prepare-investigation-brief.mjsscript7.9 KB
scripts/reconcile-candidates.mjsscript2.4 KB
scripts/render-report.mjsscript17.0 KB
scripts/scan-codebase.mjsexecutablescript11.3 KB
scripts/verify-and-regen.mjsscript14.9 KB
scripts/verify-finding.mjsexecutablescript698 B

scripts/deep-dive.mjs

View on GitHub
#!/usr/bin/env node
// Runs AFTER gate-investigations.mjs and BEFORE any sub-agent reads source.
// Attaches per-candidate evidence.deepDive to gate.toLaunch + gate.platform.
// Byte-stable apart from totalWallMs; each CLI query is isolated.

import { readFile } from 'node:fs/promises';
import { queryMetric, readProjectJson, resolveCommandScope } from '../lib/vercel.mjs';
import { specsForCandidate, mergeIntoEvidence, SCANNER_KINDS, TIME_WINDOW } from '../lib/deep-dive.mjs';

const SCHEMA_VERSION = '1.0';
const log = (...a) => console.error('[deep-dive]', ...a);

async function main() {
  // --cwd is load-bearing: the Vercel CLI resolves project/team from cwd's
  // .vercel/project.json. Outside the project, metric queries silently hit the
  // wrong team and look like "no traffic". We hard-fail on mismatch below.
  const positional = [];
  let explicitCwd = null;
  for (let i = 2; i < process.argv.length; i++) {
    const a = process.argv[i];
    if (a === '--cwd' && i + 1 < process.argv.length) {
      explicitCwd = process.argv[++i];
    } else if (a.startsWith('--cwd=')) {
      explicitCwd = a.slice('--cwd='.length);
    } else {
      positional.push(a);
    }
  }
  const mergedPath = positional[0];
  const gatePath = positional[1];
  if (!mergedPath || !gatePath) {
    console.error('usage: node scripts/deep-dive.mjs <merged.json> <gate.json> [--cwd <project-dir>]');
    process.exit(1);
  }

  const [merged, gate] = await Promise.all([
    readFile(mergedPath, 'utf-8').then(JSON.parse),
    readFile(gatePath, 'utf-8').then(JSON.parse),
  ]);

  if (explicitCwd) {
    process.chdir(explicitCwd);
    log(`cwd: ${process.cwd()} (via --cwd)`);
  }

  const link = await readProjectJson(process.cwd());
  if (!link) {
    console.error(`[deep-dive] FATAL: cwd ${process.cwd()} has no .vercel/project.json or .vercel/repo.json.`);
    console.error('         Re-run with --cwd <project-dir> pointing at the linked project, or cd into it first.');
    console.error('         (The Vercel CLI resolves team/project from cwd; without a .vercel/ linkage every query returns empty rows for the wrong team.)');
    process.exit(2);
  }
  if (merged.projectId && link.projectId !== merged.projectId) {
    console.error('[deep-dive] FATAL: cwd .vercel/ links a different project than merged.json.');
    console.error('         Re-run with --cwd <dir-linked-to-the-collected-project>.');
    process.exit(2);
  }
  if (merged.orgId && link.orgId && link.orgId !== merged.orgId) {
    console.error('[deep-dive] FATAL: cwd .vercel/ links the project to a different Vercel scope than signals.json.');
    console.error('         Re-run with --cwd <dir-linked-to-the-collected-project>, or rerun collect-signals.mjs from the intended app directory.');
    process.exit(2);
  }
  log(`cwd link OK (source ${link.source})`);

  const commandScope = await resolveDeepDiveCommandScope(merged, link);
  if (!commandScope.ok) {
    console.error(`[deep-dive] FATAL: could not resolve a CLI-safe Vercel scope (${commandScope.detail ?? commandScope.error ?? 'unknown'}).`);
    console.error('         Re-run collect-signals.mjs with the current skill, run `vercel switch <team>`, or re-link with `vercel link --yes --project <project> --team <team-slug>`.');
    process.exit(2);
  }
  if (typeof commandScope.cliScope === 'string' && /^(team|usr)_/.test(commandScope.cliScope)) {
    console.error('[deep-dive] FATAL: commandScope.cliScope is a raw account ID, not a CLI-safe scope.');
    console.error('         Re-run collect-signals.mjs with the current skill so deep-dive queries use the same team as the broad pass.');
    process.exit(2);
  }
  const commandAccountId = commandScope.teamId ?? commandScope.userId ?? null;
  if (commandAccountId && link.orgId && link.orgId !== commandAccountId) {
    console.error('[deep-dive] FATAL: cwd .vercel/ links the project to a different Vercel scope than commandScope.');
    console.error('         Re-run with --cwd <dir-linked-to-the-collected-project>, or rerun collect-signals.mjs from the intended app directory.');
    process.exit(2);
  }
  const scope = commandScope.cliScope || undefined;
  log(`command scope resolved (source=${commandScope.source}; scoped=${scope ? 'yes' : 'no'})`);

  const toLaunch = Array.isArray(gate.toLaunch) ? gate.toLaunch : [];
  const platform = Array.isArray(gate.platform) ? gate.platform : [];

  log(`enriching ${toLaunch.length} toLaunch + ${platform.length} platform candidate(s) (window=${TIME_WINDOW})`);

  const t0 = Date.now();
  const errors = [];

  // Flatten {candidate, spec}, fire all CLI calls in one Promise.all, re-group.
  // Avoids per-candidate sequentiality.
  const allCandidates = [...toLaunch.map((c, i) => ({ c, group: 'toLaunch', i })),
                        ...platform.map((c, i) => ({ c, group: 'platform', i }))];

  const flatJobs = [];
  const skipNotes = new Map();

  for (const entry of allCandidates) {
    const specs = specsForCandidate(entry.c);
    if (specs.length === 0) {
      if (SCANNER_KINDS.has(entry.c.kind)) {
        skipNotes.set(`${entry.group}:${entry.i}`, 'scanner-driven (no deep-dive needed)');
      } else if (entry.c.kind === 'platform_fluid_compute') {
        skipNotes.set(`${entry.group}:${entry.i}`, 'reused from broad pass (fnStartTypeByRoute)');
      } else {
        skipNotes.set(`${entry.group}:${entry.i}`, `no deep-dive spec for kind=${entry.c.kind}`);
      }
      continue;
    }
    for (const spec of specs) {
      flatJobs.push({ entry, spec });
    }
  }

  // Cut CLI calls two ways: (1) extract per-route slices already collected in
  // the broad pass; (2) dedupe identical queries across candidates (same route
  // can fire multiple gates wanting the same metric).
  let extractedFromBroadPass = 0;
  let dedupedQueryHits = 0;
  const broadPassResults = [];
  const remainingJobs = [];
  for (const job of flatJobs) {
    const extracted = tryExtractFromBroadPass(job.spec, merged);
    if (extracted) {
      broadPassResults.push({ entry: job.entry, spec: job.spec, ok: true, ...extracted });
      extractedFromBroadPass++;
    } else {
      remainingJobs.push(job);
    }
  }

  // One CLI call per unique dedup key; jobs sharing a key share the result.
  const queryGroups = new Map();
  for (const job of remainingJobs) {
    const key = queryKey(job.spec, scope);
    if (!queryGroups.has(key)) {
      queryGroups.set(key, { spec: job.spec, jobs: [] });
    }
    queryGroups.get(key).jobs.push(job);
  }
  dedupedQueryHits = remainingJobs.length - queryGroups.size;

  const totalCliQueries = queryGroups.size;
  log(`${flatJobs.length} specs total: ${extractedFromBroadPass} extracted from broad-pass, ${dedupedQueryHits} deduped, ${totalCliQueries} CLI queries to run`);

  const groupResults = await Promise.all([...queryGroups.values()].map(async ({ spec, jobs }) => {
    const r = await queryMetric(spec.metricId, {
      aggregation: spec.aggregation,
      groupBy: spec.groupBy,
      filter: spec.filter,
      since: spec.since,
      limit: spec.limit,
      scope,
    });
    return { spec, jobs, response: r };
  }));

  const cliResults = [];
  for (const { spec, jobs, response: r } of groupResults) {
    if (!r.ok) {
      for (const job of jobs) {
        errors.push({
          candidateGroup: job.entry.group,
          candidateIndex: job.entry.i,
          kind: job.entry.c.kind,
          route: job.entry.c.route ?? job.entry.c.hostname ?? null,
          specId: spec.id,
          code: r.code,
        });
        cliResults.push({ entry: job.entry, spec, ok: false, error: r.code });
      }
      continue;
    }
    const norm = normalizeResponse(r.data, spec);
    for (const job of jobs) {
      cliResults.push({ entry: job.entry, spec, ok: true, ...norm });
    }
  }
  const results = [...broadPassResults, ...cliResults];

  const wallMs = Date.now() - t0;
  log(`done in ${wallMs}ms (${totalCliQueries} CLI queries, ${extractedFromBroadPass} extracted from broad-pass, ${dedupedQueryHits} deduped, ${errors.length} errors)`);

  const byCandidate = new Map();
  for (const res of results) {
    const k = `${res.entry.group}:${res.entry.i}`;
    if (!byCandidate.has(k)) byCandidate.set(k, []);
    byCandidate.get(k).push(res);
  }

  function enrich(c, group, i) {
    const k = `${group}:${i}`;
    const note = skipNotes.get(k);
    if (note) {
      return {
        ...c,
        evidence: {
          ...(c.evidence ?? {}),
          deepDive: { note },
        },
      };
    }
    const list = byCandidate.get(k) ?? [];
    const merged = mergeIntoEvidence(list);
    return {
      ...c,
      evidence: {
        ...(c.evidence ?? {}),
        deepDive: merged,
      },
    };
  }

  const enrichedToLaunch = toLaunch.map((c, i) => enrich(c, 'toLaunch', i));
  const enrichedPlatform = platform.map((c, i) => enrich(c, 'platform', i));

  const out = {
    schemaVersion: SCHEMA_VERSION,
    appliedAt: new Date().toISOString(),
    candidatesEnriched: toLaunch.length + platform.length,
    specsTotal: flatJobs.length,
    queriesRun: totalCliQueries,
    extractedFromBroadPass,
    dedupedQueryHits,
    totalWallMs: wallMs,
    errors,
    toLaunch: enrichedToLaunch,
    platform: enrichedPlatform,
  };

  process.stdout.write(JSON.stringify(out, null, 2) + '\n');
}

async function resolveDeepDiveCommandScope(merged, link) {
  const linkedOrgId = merged.orgId ?? link.orgId ?? null;
  if (merged.commandScope?.ok && (merged.commandScope.cliScope || !linkedOrgId)) {
    return merged.commandScope;
  }
  if (merged.commandScope && merged.commandScope.ok === false) return merged.commandScope;

  return await resolveCommandScope({
    projectId: merged.projectId ?? link.projectId ?? null,
    orgId: merged.orgId ?? link.orgId ?? null,
  });
}

// Reduce CLI response to {value} or {rows:[{value,...dims}]}. The per-metric
// underscore field (e.g. vercel_function_invocation_count_sum) gets renamed
// to `value` for compactness.
function normalizeResponse(data, spec) {
  if (!data || !Array.isArray(data.summary)) return { value: null };
  const field = `${spec.metricId.replace(/\./g, '_')}_${spec.aggregation}`;
  if (spec.groupBy.length === 0) {
    const first = data.summary[0];
    if (!first) return { value: null };
    const v = first[field];
    return { value: typeof v === 'number' ? round4(v) : null };
  }
  const rows = data.summary.map((row) => {
    const out = { value: typeof row[field] === 'number' ? round4(row[field]) : null };
    for (const dim of spec.groupBy) {
      if (row[dim] !== undefined) out[dim] = row[dim];
    }
    return out;
  });
  return { rows };
}

function round4(n) {
  if (!Number.isFinite(n)) return n;
  return Math.round(n * 10000) / 10000;
}

// Skip the CLI call when broad-pass already collected the same metric grouped
// by [route, dim]. Returns {rows} on hit, null on miss. Cuts rate-limit pressure
// for per-route slice specs (startTypeSplit, cacheBreakdown, methodDistribution).
function tryExtractFromBroadPass(spec, merged) {
  const eq = spec.broadPassEquivalent;
  if (!eq) return null;
  const broadRows = merged?.metrics?.[eq.key]?.rows;
  if (!Array.isArray(broadRows)) return null;
  const rows = [];
  for (const row of broadRows) {
    if (row.route !== eq.routeFilter) continue;
    const out = { value: typeof row.value === 'number' ? row.value : null };
    for (const dim of (eq.projectDims ?? [])) {
      if (row[dim] !== undefined) out[dim] = row[dim];
    }
    rows.push(out);
  }
  // Zero rows ≠ "no data" — broad-pass row limit may have truncated the route.
  // Fall through to CLI so the caller gets a definitive answer.
  if (rows.length === 0) return null;
  return { rows };
}

// Two specs sharing this key answer the same question — one CLI call serves both.
// Must include everything that affects the CLI's arg list.
function queryKey(spec, scope) {
  const groupBy = [...(spec.groupBy ?? [])].sort();
  return JSON.stringify({
    metricId: spec.metricId,
    aggregation: spec.aggregation,
    groupBy,
    filter: spec.filter ?? null,
    since: spec.since ?? null,
    limit: spec.limit ?? null,
    scope: scope ?? null,
  });
}

main().catch((err) => {
  console.error('[deep-dive] FAILED:', err.message);
  console.error(err.stack);
  process.exit(1);
});
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall