Skip to content

opensite-ai/opensite-skills / aws-ai-ml

aws-ai-ml

Verified

Selects, deploys, and customizes AI models on Amazon SageMaker. Training or Processing jobs, fine-tuning (SFT/DPO/RLVR/RLAIF), model selection, dataset preparation, evaluation, SageMaker or Bedrock deployment, inference optimization and endpoint diagnostics. Covers the full lifecycle from planning through production. Use when fine-tuning models on SageMaker, choosing which base model to customize, fine-tune, or deploy from SageMaker JumpStart or Hub, SageMakerPublicHub, or the SageMaker public model catalog, transforming or validating training data, evaluating model quality, deploying or optimizing endpoints, configuring IAM/S3 for training, or managing SageMaker Managed MLflow. Use for endpoint health, failures, latency, logs, metrics, errors. Covers Serverless Model Customization, Nova and OSS deployment paths, and PySDK v3. NOT for Ground Truth labeling, Feature Store, or general-purpose AWS infrastructure.

FileKindSize
.aws-skill-metadataother18 B
SKILL.mdskill md8.1 KB
references/dataset-evaluation/overview.mdmarkdown5.4 KB
references/dataset-evaluation/references/custom-scorer-evaluation-dataset-formats.mdmarkdown3.6 KB
references/dataset-evaluation/references/strategy_data_requirements.mdmarkdown4.8 KB
references/dataset-evaluation/scripts/format_detector.pyscript26.7 KB
references/dataset-transformation/code_templates/transformation.pyscript1.5 KB
references/dataset-transformation/overview.mdmarkdown13.3 KB
references/dataset-transformation/references/code_output_guide.mdmarkdown2.8 KB
references/dataset-transformation/references/dataset_transformation_code.mdmarkdown5.2 KB
references/dataset-transformation/references/sagemaker_dataset_formats.mdmarkdown2.9 KB
references/dataset-transformation/scripts/transformation_tools.pyscript4.8 KB
references/directory-management/overview.mdmarkdown1.9 KB
references/endpoint-diagnostics/overview.mdmarkdown3.5 KB
references/endpoint-diagnostics/references/minimum_iam_policy.mdmarkdown1.2 KB
references/endpoint-diagnostics/scripts/collect_diagnostics.pyscript12.8 KB
references/finetuning-technique/overview.mdmarkdown2.1 KB
references/finetuning-technique/references/finetune_technique_selection_guide.mdmarkdown2.3 KB
references/finetuning-technique/scripts/get_recipes.pyscript817 B
references/finetuning/code_templates/dpo.pyscript6.4 KB
references/finetuning/code_templates/rlaif_builtin.pyscript5.8 KB
references/finetuning/code_templates/rlaif_custom_prompt.pyscript6.3 KB
references/finetuning/code_templates/rlvr.pyscript6.5 KB
references/finetuning/code_templates/sft.pyscript6.1 KB
references/finetuning/overview.mdmarkdown11.4 KB
references/finetuning/references/code_output_guide.mdmarkdown3.2 KB
references/finetuning/references/continuous_customization.mdmarkdown8.4 KB
references/finetuning/references/eula_links.mdmarkdown7.3 KB
references/finetuning/references/rlaif_guide.mdmarkdown3.8 KB
references/finetuning/references/rlvr_reward_function.mdmarkdown10.0 KB
references/finetuning/scripts/mlflow_reference.pyscript841 B
references/finetuning/templates/nova_rlvr_reward_function_source_template.pyscript12.8 KB
references/finetuning/templates/rlvr_reward_function_source_template.pyscript9.1 KB
references/manage-mlflow/overview.mdmarkdown4.8 KB
references/manage-mlflow/references/app-creation-workflow.mdmarkdown3.2 KB
references/manage-mlflow/references/app-deletion-workflow.mdmarkdown2.3 KB
references/manage-mlflow/references/app-discovery-workflow.mdmarkdown1.5 KB
references/manage-mlflow/references/app-update-workflow.mdmarkdown1.7 KB
references/manage-mlflow/references/sm-mlflow-guide.mdmarkdown1.3 KB
references/model-deployment/code_templates/deploy-jumpstart-sagemaker.pyscript7.5 KB
references/model-deployment/code_templates/deploy-nova-bedrock.pyscript2.0 KB
references/model-deployment/code_templates/deploy-nova-sagemaker.pyscript1.9 KB
references/model-deployment/code_templates/deploy-oss-bedrock.pyscript4.0 KB
references/model-deployment/code_templates/deploy-oss-sagemaker.pyscript2.6 KB
references/model-deployment/code_templates/optimize-benchmark.pyscript4.6 KB
references/model-deployment/code_templates/optimize-huggingface-to-s3.pyscript2.0 KB
references/model-deployment/code_templates/optimize-recommendation.pyscript6.4 KB
references/model-deployment/overview.mdmarkdown16.6 KB
references/model-deployment/references/code_output_guide.mdmarkdown3.2 KB
references/model-deployment/references/deploy-jumpstart-sagemaker.mdmarkdown14.3 KB
references/model-deployment/references/deploy-nova-bedrock.mdmarkdown4.4 KB
references/model-deployment/references/deploy-nova-sagemaker.mdmarkdown5.8 KB
references/model-deployment/references/deploy-oss-bedrock.mdmarkdown5.2 KB
references/model-deployment/references/deploy-oss-sagemaker.mdmarkdown12.9 KB
references/model-deployment/references/model-licenses.mdmarkdown11.9 KB
references/model-deployment/references/optimization/benchmark-workflow.mdmarkdown12.7 KB
references/model-deployment/references/optimization/benchmarking-guidance.mdmarkdown8.9 KB
references/model-deployment/references/optimization/huggingface-to-s3.mdmarkdown3.1 KB
references/model-deployment/references/optimization/interpreting-results.mdmarkdown8.5 KB
references/model-deployment/references/optimization/recommendation-deploy.mdmarkdown1.5 KB
references/model-deployment/references/optimization/recommendation-options.mdmarkdown3.1 KB
references/model-deployment/references/optimization/recommendation-workflow.mdmarkdown10.3 KB
references/model-evaluation/code_templates/custom_scorer_evaluator.pyscript2.5 KB
references/model-evaluation/code_templates/llmaaj_evaluator.pyscript2.8 KB
references/model-evaluation/overview.mdmarkdown5.2 KB
references/model-evaluation/references/code_output_guide.mdmarkdown3.3 KB
references/model-evaluation/references/create-reward-function.mdmarkdown3.0 KB
references/model-evaluation/references/custom-lambda-scorer.mdmarkdown4.4 KB
references/model-evaluation/references/custom-scorer-evaluation.mdmarkdown10.5 KB
references/model-evaluation/references/evaluation-type-guide.mdmarkdown10.1 KB
references/model-evaluation/references/llmaaj-builtin-evaluation.mdmarkdown5.0 KB
references/model-evaluation/references/llmaaj-custom-evaluation.mdmarkdown2.5 KB
references/model-evaluation/references/llmaaj-evaluation.mdmarkdown14.6 KB
references/model-evaluation/references/supported-judge-models.mdmarkdown2.9 KB
references/model-evaluation/scripts/nova_reward_function_source_template.pyscript13.1 KB
references/model-evaluation/scripts/reward_function_source_template.pyscript9.2 KB
references/model-evaluation/scripts/validate_custom_metrics.pyscript3.5 KB
references/model-selection/overview.mdmarkdown10.3 KB
references/model-selection/references/benchmarks/agentic-index.mdmarkdown2.8 KB
references/model-selection/references/benchmarks/coding-index.mdmarkdown2.8 KB
references/model-selection/references/benchmarks/gpqa.mdmarkdown2.8 KB
references/model-selection/references/benchmarks/hle.mdmarkdown2.8 KB
references/model-selection/references/benchmarks/ifbench.mdmarkdown2.8 KB
references/model-selection/references/benchmarks/intelligence-index.mdmarkdown2.8 KB
references/model-selection/references/benchmarks/mmmu-pro.mdmarkdown3.0 KB
references/model-selection/references/benchmarks/tau2.mdmarkdown2.8 KB
references/model-selection/references/model-licenses.mdmarkdown7.3 KB
references/model-selection/references/model-selection.mdmarkdown8.2 KB
references/model-selection/references/select-for-deployment.mdmarkdown19.8 KB
references/model-selection/scripts/filter_deployable_models.pyscript10.1 KB
references/model-selection/scripts/get_deployable_models.pyscript21.7 KB
references/model-selection/scripts/get_model_names.pyscript1.4 KB
references/model-selection/scripts/search_deployable_models.pyscript34.9 KB
references/planning/overview.mdmarkdown10.3 KB
references/planning/references/deploy-base-model-plan.mdmarkdown699 B
references/planning/references/evaluate-first-plan.mdmarkdown1.8 KB
references/planning/references/input-output-contracts.mdmarkdown3.1 KB
references/planning/references/model-customization-plan.mdmarkdown1.5 KB
references/planning/references/region-availability.mdmarkdown1.2 KB
references/planning/references/skill-routing-constraints.mdmarkdown2.7 KB
references/processing-jobs/code_templates/dataset_definition_processing.pyscript4.1 KB
references/processing-jobs/code_templates/framework_processing.pyscript3.0 KB
references/processing-jobs/code_templates/script_processing.pyscript2.9 KB
references/processing-jobs/code_templates/spark_processing.pyscript3.7 KB
references/processing-jobs/overview.mdmarkdown6.7 KB
references/processing-jobs/references/configuration.mdmarkdown4.6 KB
references/processing-jobs/references/troubleshooting.mdmarkdown2.4 KB
references/sdk-getting-started/overview.mdmarkdown643 B
references/sdk-getting-started/references/execution-role-setup.mdmarkdown2.4 KB
references/sdk-getting-started/references/sagemaker-python-sdk-setup.mdmarkdown2.1 KB
references/training-jobs/code_templates/custom_training.pyscript6.2 KB
references/training-jobs/code_templates/jumpstart_training.pyscript5.6 KB
references/training-jobs/code_templates/recipe_training.pyscript5.7 KB
references/training-jobs/overview.mdmarkdown9.1 KB
references/training-jobs/references/configuration.mdmarkdown4.0 KB
references/training-jobs/references/troubleshooting.mdmarkdown4.4 KB
references/use-case-specification/overview.mdmarkdown2.0 KB
references/use-case-specification/references/spec-for-deployment.mdmarkdown3.9 KB
references/use-case-specification/references/spec-for-finetuning.mdmarkdown2.0 KB

references/model-deployment/references/deploy-jumpstart-sagemaker.md

View on GitHub
# Deploy a JumpStart Foundation Model to a SageMaker Endpoint

## Scenario

- **Model Type**: open-weight foundation model resolved through **SageMaker JumpStart** (a base
  model, identified by a JumpStart model id — NOT a fine-tuned training job)
- **Deployment Target**: SageMaker real-time endpoint
- **Approach**: SageMaker Python SDK v3 `ModelBuilder.from_jumpstart_config(...)`, deployed from the
  **deployment config emitted by the model-selection skill**

## Overview

Deploys a base JumpStart foundation model to a real-time endpoint. This pathway is the deployment
half of the base-model flow: the **model-selection** skill chose the model and instance type (and,
where the model has hosting configs, the config it optimized for) and hands them over. This skill
maps those onto the v3 SDK config objects and does **not** re-derive anything from the model spec.
It is a thin passthrough with safe defaults for the fields model-selection does not supply (see the
input contract below).

The v3 SDK (`sagemaker>=3.7.1`) has **no** `sagemaker.jumpstart` module and **no** `JumpStartModel`
class. A JumpStart model is deployed by building a `JumpStartConfig` + `Compute` and calling
`ModelBuilder.from_jumpstart_config(...)`. The SDK resolves the serving container, environment, and
inference-component sizing internally from the config — the deployment code never digs into the
model spec or `HubContentDocument`.

### The input contract (from model-selection)

The template consumes a flat `CONFIG` dict. model-selection's Step 6 hand-off emits **three**
fields — `model_id`, `instance_type`, and `inference_config_name`. The remaining fields are
deployment-side with safe defaults.

| Config field            | v3 destination                                    | Producer / default                                              |
| ----------------------- | ------------------------------------------------- | --------------------------------------------------------------- |
| `model_id`              | `JumpStartConfig.model_id` (required)             | **model-selection** (Hub model ID)                              |
| `instance_type`         | `Compute.instance_type` (required)                | **model-selection** (user-confirmed)                            |
| `inference_config_name` | `JumpStartConfig.inference_config_name`           | **model-selection** (the config it chose; `null` when the model has no labeled configs) |
| `model_version`         | `JumpStartConfig.model_version` (`None` → `"*"`)  | deployment default `None` (latest) unless supplied              |
| `instance_count`        | `Compute.instance_count`                          | deployment default `1` unless supplied                          |
| `accept_eula`           | `JumpStartConfig.accept_eula`                     | deployment-owned (set at the Step 4 license gate)               |
| `env_vars`              | `from_jumpstart_config(env_vars=...)`             | deployment default `None` unless supplied                       |

`inference_config_name` is tri-state: a real config name deploys that specific config; `None` lets
the SDK resolve the spec's top-ranked config; `None` for a model with no labeled configs is a plain
base deploy. Deployment honors whatever value it receives — never override it. model-selection emits
the config it chose precisely so deployment does not fall back to the top-ranked config (which may
not support the `instance_type` that was derived from the chosen config — see "Instance ↔ config
consistency" below).

`model_id` and `instance_type` are **both required** for a real-time endpoint. The template
fails fast if either is missing.

### Hardening the hand-off

The config comes from another skill, so treat it as untrusted. The template's Cell 2 defines
`validate_deployment_config(cfg)` and calls it before building — it fails fast with a clear,
actionable message when the config is missing fields or otherwise broken, rather than failing deep
in the SDK or silently misbehaving. It checks:

- `CONFIG` is a dict (a `None`/list/string hand-off is rejected with a readable error)
- `model_id` and `instance_type` are non-empty strings and not un-substituted placeholders
- `instance_count` is a positive integer (`bool` rejected — it is a subclass of `int`)
- `model_version` is a string or `None`
- `inference_config_name` is a non-empty name or `None` (an empty string would be treated as a
  real config name and fail deep in the SDK)
- `accept_eula` is a **real bool** — a non-bool such as the string `"false"` is truthy in Python
  and could silently auto-accept a gated model's license, so it is rejected (a safety check)
- `env_vars` is `None` or a flat dict of string → string

Keep this validator in the generated notebook. It is the runtime guard; the agent-time check in
Step 1 is the first line of defence.

### Deployment-owned fields (NOT from model-selection)

`role_arn`, `endpoint_name`, and `model_name` are owned by this skill, not model-selection. Collect
them in the steps below.

## Prerequisites

### SDK Version

Requires `sagemaker>=3.7.1` (the template pins `>=3.7.1,<4.0` to guard against a future v4 breaking
this API the way v2→v3 did). Do not use the v2 `JumpStartModel` / `sagemaker.enums.EndpointType`
/ `sagemaker.compute_resource_requirements` imports — they do not exist in v3.

## Key Gotchas

- **Do not re-resolve the config.** model-selection already picked `instance_type` and
  `inference_config_name`. Do not call `get_config_names` / `list_deployment_configs` or read the
  `HubContentDocument` here — pass the dict through. The SDK resolves container/env/sizing from the
  config name.
- **`inference_config_name` must be valid or `None`.** A name the model doesn't expose fails inside
  `from_jumpstart_config`. model-selection validates the name against `get_config_names` before
  emitting it, so treat a non-`None` value as trusted.
- **Instance ↔ config consistency.** If both `instance_type` and `inference_config_name` are set,
  the instance must be in that config's `supported_inference_instance_types` (server-side ranking
  rejects otherwise). model-selection guarantees this; surface the SDK error cleanly if it occurs.
- **Gated models**: `accept_eula` defaults to `False`, which is safe for non-gated models. It is set
  to `True` only after the user explicitly accepted the license in Step 4. Whether a model is gated
  is given by the **Gated (EULA)** column in `model-licenses.md` (a `Yes` row is gated — e.g.
  Meta/Llama, Gemma, NVIDIA Nemotron, Llama 4, Qwen License Agreement); it is a property of the
  license terms, not the vendor. Never auto-accept.

## Topology note (single-model endpoint)

`from_jumpstart_config(...).deploy(endpoint_name=...)` deploys a **single-model real-time
endpoint**. Inference-component (IC) packing is not part of this contract yet — adding it requires
a new field in the model-selection → deployment config (e.g. `endpoint_type` plus resource
requirements) so both skills agree. Until that field exists, deploy the single-model endpoint as
above.

## Workflow

### Step 1: Confirm and validate the deployment config

You should already have the config dict from the model-selection skill (`model_id`,
`instance_type`, `inference_config_name`, etc.). Before generating any code, sanity-check the
hand-off:

- It must contain a non-empty `model_id` and `instance_type`.
- `accept_eula`, if present, must be a boolean (not a string).
- `inference_config_name`, if present, must be a real name or `null` — never an empty string.

If the config is missing, not a dict, or missing either required field, do **not** generate a
deploy notebook. Go back to the model-selection skill to produce a valid config rather than
guessing values. The generated notebook also self-validates at runtime (see "Hardening the
hand-off" above), but catching it here avoids emitting a notebook that will fail.

### Step 2: Verify IAM Role

`role_arn` is owned by this skill, not model-selection, and a JumpStart base deploy has no training
job to extract it from. Use the IAM execution role identified in Step 1 of the main workflow; if it
is not already known, ASK the user for the IAM execution role ARN. Confirm it with the user.

### Step 3: Confirm Region

The region was identified in Step 1 of the main workflow. If it is not already known, ASK the user
for the AWS region. Confirm it with the user.

### Step 4: Confirm Configuration

> "Here's the deployment setup:
>
> - Target: SageMaker real-time endpoint
> - JumpStart model: [model_id]
> - Inference config: [inference_config_name, or "SDK top-ranked default"]
> - Instance type: [instance_type] x [instance_count]
> - IAM Role: [role_arn]
> - Region: [region]
>
> Does this look right?"

⏸ Wait for user approval.

### Step 5: Generate Code

Read `../references/code_output_guide.md` for output format rules.

If a project directory already exists (from earlier in the workflow), use it. Otherwise, activate
the **directory-management** skill to set one up.

⏸ Wait for user.

## Code Structure

### Markdown Header

Begin the notebook with a markdown cell whose only content is the title
`# Deploy a JumpStart Foundation Model to SageMaker`.

### Cells

Each cell's content comes from `../code_templates/deploy-jumpstart-sagemaker.py`, split on the
`# Cell N:` comments. Each marker starts a new notebook cell.

- **Cell 1**: Setup (pip install)
- **Cell 2**: Configuration and validation (the config dict from model-selection + deployment-owned
  fields, plus `validate_deployment_config` which runs before the build)
- **Cell 3**: Build the model via `from_jumpstart_config`
- **Cell 4**: Deploy and wait for InService
- **Cell 5**: Test Inference
- **Cell 6**: Save Manifest

### Placeholders

The `CONFIG` dict fields (from model-selection):

- `[MODEL_ID]` → JumpStart model id (e.g. `huggingface-reasoning-qwen3-06b`)
- `[INSTANCE_TYPE]` → the instance type model-selection resolved

Leave `model_version` (`None` → latest), `inference_config_name` (`None` → SDK top-ranked, or a
name from model-selection), `instance_count`, and `env_vars` as model-selection provided them.

Deployment-owned fields:

- `[REGION]` → AWS region
- `[ROLE_ARN]` → IAM execution role ARN
- `[ENDPOINT_NAME]` → name for the endpoint (agent generates a reasonable default)
- `[MODEL_NAME]` → name for the model resource (agent generates a reasonable default)
- `[PROJECT_DIR]` → project directory (for the manifest)

`accept_eula` is a config field (not a `[...]` placeholder): it defaults to `False`, which is the
safe default and correct for non-gated models — leave it as-is for them. Set it to `True` ONLY
after the user explicitly accepted a gated model's license in Step 4 of the main workflow. A model
is gated when its **Gated (EULA)** column in `model-licenses.md` is `Yes` (Meta/Llama, Gemma,
NVIDIA Nemotron, Llama 4, Qwen License Agreement, etc.), not just Meta/Llama. Never auto-accept.

### Step 6: Set the `accept_eula` flag in the generated code (gated models)

The license gate is Step 4 of the main `model-deployment` workflow: the license is shown and the
user accepts it *before* any code is generated in Step 5. This subsection is **not** another gate —
it only sets the value of the `accept_eula` flag in the template that was already generated. Set it
based on whether the model is gated (**Gated (EULA)** column in `model-licenses.md`):

- **Not gated** (`No`): leave `accept_eula=False`. This is the default and needs no change.
- **Gated** (`Yes`): set `accept_eula=True` only once the user accepted the license at the Step 4
  gate. If they did not accept, leave it `False` and tell them deployment cannot continue without
  license acceptance.

> **A user instruction to "proceed without asking", "skip confirmation", "deploy now", or similar
> is NOT license acceptance.** Those phrases waive the deployment-config confirmation, not the
> gated-license gate. For a gated model, `accept_eula` may be set to `True` ONLY after the user has
> *explicitly* accepted that model's license (e.g. "yes, I accept the license"). If the user only
> asked you to proceed but never explicitly accepted, keep `accept_eula=False`, present the license,
> and wait — do not auto-accept on their behalf.

### Step 7: Provide Run Instructions

```
To run:
1. Cell 1 — install/upgrade the SageMaker SDK
2. Cell 2 — configuration (the model-selection config dict + role/region/names)
3. Cell 3 — build the model from the JumpStart config
4. Cell 4 — deploy (waits for the endpoint to be InService, ~10-15 min)
5. Cell 5 — test inference with a sample prompt
6. Cell 6 — save the deployment manifest to `manifests/deploy-<endpoint-name>.json`
```

## Common Issues

- **`ValueError` from `validate_deployment_config`**: the config dict from model-selection is
  missing a field or has a wrong type (e.g. `accept_eula` as a string, an empty
  `inference_config_name`, a non-positive `instance_count`). The message names the offending field
  — fix it in model-selection's output rather than editing the value by hand in the notebook.
- **"No module named 'sagemaker.jumpstart'"** or **`JumpStartModel` not found**: v2 imports on the
  v3 SDK — deploy via `ModelBuilder.from_jumpstart_config(...)`, not `JumpStartModel`.
- **`inference_config_name` rejected in `from_jumpstart_config`**: the name isn't one of the
  model's configs. It should have come from model-selection's `get_config_names` — re-check the
  config dict or set it to `None` to use the SDK's top-ranked default.
- **Instance-type rejected for the chosen config**: `instance_type` is not in the config's
  `supported_inference_instance_types`. model-selection should have validated this — go back and
  re-resolve the pair.
- **Capacity error on a scarce GPU instance**: the config's recommended instance family may be
  capacity-constrained — reach out to AWS Support / your account team (a Service Quotas increase
  does not guarantee capacity), or have model-selection pick a different config.

## Post-Deployment Summary

After the notebook runs successfully, tell the user:

- **Endpoint**: `[ENDPOINT_NAME]` is now InService, running `[MODEL_ID]` on `[INSTANCE_TYPE]`.
- **How to invoke**: use the SageMaker runtime `InvokeEndpoint`.
- **Billing**: this endpoint is billed by the hour while running, even when idle. Delete it when
  you're done testing.
- **Cleanup**: delete the endpoint (and its endpoint config / model) using the AWS MCP tool
  (`delete-endpoint`, then `delete-endpoint-config`, then `delete-model`).
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