Skip to content

notque/vexjoy-agent / skills/game/game-dev

game-dev

Flagged

Game development: design, asset pipelines, Phaser, Unity CLI and builds, vanilla JS frontend, GM mode, match booking.

FileKindSize
SKILL.mdskill md13.2 KB
references/anchor-alignment.mdmarkdown16.0 KB
references/animate-scaffolds.mdmarkdown2.0 KB
references/arcade-physics.mdmarkdown7.4 KB
references/artifacts-and-prototyping.mdmarkdown1.5 KB
references/asset-sources.mdmarkdown7.9 KB
references/audit-and-red-team.mdmarkdown795 B
references/autonomous-improvement.mdmarkdown10.3 KB
references/backend-chain.mdmarkdown10.4 KB
references/bg-removal-local.mdmarkdown22.7 KB
references/build-scaffolds.mdmarkdown2.0 KB
references/capabilities/01-design-red-team-audit.mdmarkdown3.9 KB
references/capabilities/02-emotional-canvas-moodboard.mdmarkdown3.7 KB
references/capabilities/03-game-design-attribution-audit.mdmarkdown3.6 KB
references/capabilities/04-game-design-bartle-archetype-audit.mdmarkdown3.7 KB
references/capabilities/05-game-design-big-five-personality-audit.mdmarkdown3.6 KB
references/capabilities/06-game-design-brainstorm-methods.mdmarkdown3.9 KB
references/capabilities/07-game-design-core-loop-extractor.mdmarkdown3.7 KB
references/capabilities/08-game-design-craft-critique.mdmarkdown3.5 KB
references/capabilities/09-game-design-creative-unblocker.mdmarkdown3.5 KB
references/capabilities/10-game-design-design-pillars-extractor.mdmarkdown3.5 KB
references/capabilities/11-game-design-emotional-canvas.mdmarkdown3.6 KB
references/capabilities/12-game-design-failure-loop-audit.mdmarkdown3.8 KB
references/capabilities/13-game-design-fairness-frustration-audit.mdmarkdown3.6 KB
references/capabilities/14-game-design-fantasy-extractor.mdmarkdown3.6 KB
references/capabilities/15-game-design-feature-prioritization.mdmarkdown3.6 KB
references/capabilities/16-game-design-five-options.mdmarkdown3.5 KB
references/capabilities/17-game-design-flow-audit.mdmarkdown3.6 KB
references/capabilities/18-game-design-fogg-behavior-audit.mdmarkdown3.6 KB
references/capabilities/19-game-design-friction-journey-audit.mdmarkdown3.8 KB
references/capabilities/20-game-design-ftue-hero-journey-audit.mdmarkdown3.7 KB
references/capabilities/21-game-design-goal-density-and-immediacy-audit.mdmarkdown3.5 KB
references/capabilities/22-game-design-goal-framing.mdmarkdown3.5 KB
references/capabilities/23-game-design-granular-player-motivation-audit.mdmarkdown4.0 KB
references/capabilities/24-game-design-grow-design.mdmarkdown3.5 KB
references/capabilities/25-game-design-ideal-outcome-backcasting.mdmarkdown3.4 KB
references/capabilities/26-game-design-kpi-coverage-audit.mdmarkdown3.8 KB
references/capabilities/27-game-design-leaderboard-audit.mdmarkdown3.9 KB
references/capabilities/28-game-design-leaderboard-builder.mdmarkdown3.8 KB
references/capabilities/29-game-design-molyneux-lens.mdmarkdown3.5 KB
references/capabilities/30-game-design-multiplayer-feature-audit.mdmarkdown3.8 KB
references/capabilities/31-game-design-novelty-spectrum-audit.mdmarkdown3.6 KB
references/capabilities/32-game-design-one-page-design-doc.mdmarkdown3.8 KB
references/capabilities/33-game-design-one-thing-to-remove.mdmarkdown3.6 KB
references/capabilities/34-game-design-option-generation.mdmarkdown3.5 KB
references/capabilities/35-game-design-peak-end-audit.mdmarkdown3.6 KB
references/capabilities/36-game-design-perceived-randomness-audit.mdmarkdown3.7 KB
references/capabilities/37-game-design-pitch-deck-audit.mdmarkdown3.8 KB
references/capabilities/38-game-design-player-motivation-audit.mdmarkdown3.5 KB
references/capabilities/39-game-design-player-need-satisfaction-audit.mdmarkdown3.6 KB
references/capabilities/40-game-design-player-persona-extractor.mdmarkdown4.2 KB
references/capabilities/41-game-design-player-perspective-reframe.mdmarkdown3.7 KB
references/capabilities/42-game-design-player-segment-perception-audit.mdmarkdown3.6 KB
references/capabilities/43-game-design-player-values-mapper.mdmarkdown3.8 KB
references/capabilities/44-game-design-premium-pass-audit.mdmarkdown3.8 KB
references/capabilities/45-game-design-prosocial-session-chapters.mdmarkdown3.7 KB
references/capabilities/46-game-design-prototype-intent-audit.mdmarkdown3.7 KB
references/capabilities/47-game-design-prototyping-companion.mdmarkdown3.6 KB
references/capabilities/48-game-design-roadblock-reframing.mdmarkdown3.5 KB
references/capabilities/49-game-design-smart-goal-audit.mdmarkdown3.6 KB
references/capabilities/50-game-design-social-satisfaction-matrix.mdmarkdown3.7 KB
references/capabilities/51-game-design-systematizing-empathizing-audit.mdmarkdown3.6 KB
references/capabilities/52-game-design-thinking-fast-and-slow-audit.mdmarkdown3.6 KB
references/capabilities/53-game-design-transformative-reuse.mdmarkdown3.6 KB
references/capabilities/54-game-design-unknown-unknowns-prototyping.mdmarkdown3.6 KB
references/capabilities/55-game-design-zeigarnik-effect-audit.mdmarkdown3.6 KB
references/capabilities/56-game-dev-budget-estimator.mdmarkdown3.8 KB
references/capabilities/57-game-dev-first-steps.mdmarkdown3.6 KB
references/capabilities/58-game-dev-team-gap.mdmarkdown3.6 KB
references/capabilities/59-game-dev-time-estimator.mdmarkdown3.8 KB
references/capabilities/60-moodboard-generator.mdmarkdown4.0 KB
references/capabilities/61-software-team-conflict-patterns.mdmarkdown3.8 KB
references/capability-catalog.mdmarkdown18.4 KB
references/capability-map.mdmarkdown1.7 KB
references/capability-matrix.mdmarkdown12.5 KB
references/capacitor-ios.mdmarkdown7.3 KB
references/cognition-and-choice.mdmarkdown1.2 KB
references/cognitive-and-behavioral-lenses.mdmarkdown1.2 KB
references/concept-and-loop.mdmarkdown1.5 KB
references/core-loop-and-pillars.mdmarkdown835 B
references/core-patterns.mdmarkdown8.2 KB
references/cpu-systems-harmony.mdmarkdown3.4 KB
references/creative-and-options.mdmarkdown2.0 KB
references/creative-direction.mdmarkdown1.3 KB
references/deploy.mdmarkdown5.3 KB
references/design-artifacts.mdmarkdown1.0 KB
references/emotion-and-presentation.mdmarkdown1.1 KB
references/error-catalog.mdmarkdown22.6 KB
references/fairness-and-failure.mdmarkdown1.2 KB
references/fairness-and-learning.mdmarkdown1.3 KB
references/fal-ai-image.mdmarkdown7.1 KB
references/frame-detection.mdmarkdown20.0 KB
references/full-diagnostic.mdmarkdown4.2 KB
references/game-asset-generator.mdmarkdown9.5 KB
references/game-audio.mdmarkdown7.5 KB
references/game-feel-patterns.mdmarkdown12.2 KB
references/game-pipeline.mdmarkdown11.5 KB
references/game-qa.mdmarkdown6.7 KB
references/game-sprite-pipeline.mdmarkdown33.4 KB
references/gm-brilliant-implementation.mdmarkdown13.4 KB
references/grid-shapes.mdmarkdown8.0 KB
references/meshyai.mdmarkdown7.3 KB
references/motion-pipeline.mdmarkdown7.5 KB
references/output-formats.mdmarkdown9.4 KB
references/pacing-and-return.mdmarkdown1.6 KB
references/performance.mdmarkdown7.8 KB
references/phaser-gamedev.mdmarkdown7.5 KB
references/pipeline-spec.jsonconfig23.0 KB
references/pixel-art-sprites.mdmarkdown8.7 KB
references/planning-and-communication.mdmarkdown1.6 KB
references/planning-and-production.mdmarkdown1.8 KB
references/player-and-social.mdmarkdown2.3 KB
references/polish-scaffolds.mdmarkdown1.9 KB
references/progression-and-economy.mdmarkdown1.0 KB
references/promo-video.mdmarkdown6.6 KB
references/prompt-rules.mdmarkdown15.2 KB
references/quality-gates.mdmarkdown6.4 KB
references/road-to-aew-integration.mdmarkdown7.8 KB
references/social-and-competitive-design.mdmarkdown1.1 KB
references/social-and-competitive.mdmarkdown1.5 KB
references/spritesheets.mdmarkdown6.2 KB
references/stage-contracts.mdmarkdown11.1 KB
references/style-presets.mdmarkdown5.1 KB
references/subagent-delegation.mdmarkdown2.2 KB
references/tilemaps-and-physics.mdmarkdown13.6 KB
references/tilemaps.mdmarkdown7.0 KB
references/unity-batchmode-builds.mdmarkdown9.2 KB
references/unity-cli.mdmarkdown10.9 KB
references/unity-licensing.mdmarkdown5.0 KB
references/vfx-containment.mdmarkdown3.1 KB
references/workflow-dag.mdmarkdown4.1 KB
references/worldlabs.mdmarkdown7.9 KB
references/wrestler-archetypes.mdmarkdown7.2 KB
scripts/deterministic_idle.pyscript7.8 KB
scripts/fal_queue_image_run.pyscript9.4 KB
scripts/imgdiff.pyscript5.0 KB
scripts/meshy-generate.mjsscript11.1 KB
scripts/optimize-glb.mjsscript3.8 KB
scripts/portrait_pipeline.pyscript31.2 KB
scripts/qa_artifacts.pyscript14.4 KB
scripts/road_to_aew_integration.pyscript6.6 KB
scripts/row_job_status.pyscript8.6 KB
scripts/sprite_anchor.pyscript30.1 KB
scripts/sprite_assemble.pyscript16.0 KB
scripts/sprite_bg.pyscript28.5 KB
scripts/sprite_canvas.pyscript11.9 KB
scripts/sprite_generate.pyscript13.9 KB
scripts/sprite_pipeline.pyscript54.9 KB
scripts/sprite_process.pyscript13.5 KB
scripts/sprite_prompt.pyscript41.8 KB
scripts/sprite_slicing.pyscript38.7 KB
scripts/sprite_verify.pyscript58.5 KB
scripts/test_content_aware_extraction.pyscript13.4 KB
scripts/test_no_status_laundering.pyscript6.9 KB
scripts/test_phases_4_5_7_8.pyscript16.4 KB
scripts/test_pipeline_glue.pyscript20.9 KB
scripts/test_pipeline_patterns.pyscript10.9 KB
scripts/test_rc3_frames_distinct_threshold.pyscript14.2 KB
scripts/test_rc4_mass_centroid_default.pyscript8.3 KB
scripts/test_rc5_despill_pre_upscale.pyscript7.9 KB
scripts/test_slice_grid_cells.pyscript6.4 KB
scripts/test_slicer_strict_pitch_default.pyscript11.6 KB
scripts/test_verifier_cell_parity.pyscript9.0 KB
scripts/test_verify_gates.pyscript23.2 KB
scripts/tests/test_fal_queue_image_run.pyscript908 B
scripts/video_extract_frames.pyscript4.3 KB
scripts/video_process_frames.pyscript7.6 KB
scripts/video_select_frames.pyscript6.4 KB
scripts/with_server.pyscript5.8 KB

scripts/sprite_generate.py

View on GitHub
#!/usr/bin/env python3
"""
Backend dispatcher for the game-sprite-pipeline skill.

Selects between Codex CLI imagegen (primary) and Gemini Nano Banana
(fallback). Fails loudly when neither backend is available -- the skill
does NOT call paid APIs directly.

Subcommands:
    generate-portrait       Single portrait image
    generate-character      Phase A: 1024x1024 reference character (spritesheet mode)
    generate-spritesheet    Phase C: full spritesheet generation

Usage:
    python3 sprite_generate.py generate-portrait \\
        --prompt-file prompt.txt --output portrait.png --seed 42

The script never touches paid endpoints. Detection logic:
    1. `codex` in PATH and `codex --version` exits 0 -> Codex CLI.
    2. GEMINI_API_KEY (or GOOGLE_API_KEY) set -> Nano Banana.
    3. Else: BackendUnavailableError with explicit fix instructions.
"""

from __future__ import annotations

import argparse
import logging
import os
import shutil
import subprocess
import sys
from dataclasses import dataclass
from pathlib import Path

logger = logging.getLogger("sprite-pipeline.sprite_generate")

# Resolve nano-banana script paths. Prefer ~/.claude/scripts/ (deployed),
# fall back to repo path when running in a dev checkout.
NANO_BANANA_GENERATE_CANDIDATES = [
    Path.home() / ".claude" / "scripts" / "nano-banana-generate.py",
    Path("/home/feedgen/.claude/scripts/nano-banana-generate.py"),
]


def find_nano_banana_script() -> Path | None:
    """Return the first existing nano-banana-generate.py path."""
    for candidate in NANO_BANANA_GENERATE_CANDIDATES:
        if candidate.exists():
            return candidate
    return None


class BackendUnavailableError(RuntimeError):
    """Raised when no image-generation backend is available."""


@dataclass
class BackendChoice:
    backend: str  # 'codex' | 'nano-banana'
    detected_via: str


def select_backend() -> BackendChoice:
    """Detect which backend to use. Fail loudly if none available."""
    if shutil.which("codex"):
        try:
            subprocess.run(
                ["codex", "--version"],
                check=True,
                capture_output=True,
                timeout=10,
            )
            return BackendChoice(backend="codex", detected_via="codex --version exit 0")
        except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError) as e:
            logger.warning(
                "[backend] codex CLI present but auth check failed (%s); trying Nano Banana",
                e,
            )

    if os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY"):
        return BackendChoice(backend="nano-banana", detected_via="GEMINI_API_KEY env set")

    raise BackendUnavailableError(
        "No image-generation backend available.\n\n"
        "Tried in order:\n"
        "  1. Codex CLI (`codex` not in PATH or auth failed)\n"
        "  2. Gemini Nano Banana (GEMINI_API_KEY not set)\n\n"
        "This skill does not call paid APIs directly. To proceed:\n"
        "  - Install Codex CLI and run `codex auth`, OR\n"
        "  - Set GEMINI_API_KEY: export GEMINI_API_KEY=<your-key>\n\n"
        "Never set OPENAI_API_KEY for this skill -- paid fallbacks are\n"
        "intentionally prohibited per the Local-First principle."
    )


def read_prompt(prompt: str | None, prompt_file: Path | None) -> str:
    """Resolve the prompt from --prompt or --prompt-file."""
    if prompt and prompt_file:
        raise ValueError("Pass either --prompt OR --prompt-file, not both.")
    if prompt:
        return prompt
    if prompt_file:
        return prompt_file.read_text(encoding="utf-8")
    raise ValueError("Must pass --prompt or --prompt-file.")


# ---------------------------------------------------------------------------
# Codex CLI dispatch
# ---------------------------------------------------------------------------
def generate_via_codex(
    prompt: str,
    output: Path,
    aspect_ratio: str | None = None,
    reference: Path | list[Path] | None = None,
    seed: int = 0,
    model: str = "image-1",
) -> int:
    """Run Codex CLI imagegen via subprocess. Returns exit code.

    Codex CLI 0.125+ does not expose --output-image / --aspect-ratio /
    --reference / --seed flags directly. Image generation happens through
    the agent's internal image_gen tool: we PROMPT codex exec to use that
    tool and save to an absolute path, then verify the file exists. The
    aspect_ratio / reference / seed values are encoded into the prompt
    itself rather than as CLI flags. See this module's `generate_via_codex`
    callers for how the prompt is constructed and post-verified.
    """
    output.parent.mkdir(parents=True, exist_ok=True)

    extras: list[str] = []
    if aspect_ratio:
        extras.append(f"Aspect ratio target: {aspect_ratio}.")
    if seed:
        extras.append(f"Seed (encode in image_gen call when supported): {seed}.")

    ref_count = len(reference) if isinstance(reference, list) else (1 if reference else 0)
    if ref_count > 1:
        ref_note = (
            "\nReference images attached: image 1 is the magenta GRID CANVAS "
            "TEMPLATE — use it to locate cell boundaries and place exactly "
            "one frame per cell. Image 2 is the CHARACTER REFERENCE — "
            "preserve this character's identity (face, hair, costume, "
            "colors, body type) in every cell.\n"
        )
    elif ref_count == 1:
        ref_note = (
            "\nReference image attached: use it as the structural / identity reference for the generated image.\n"
        )
    else:
        ref_note = ""

    wrapped = (
        "Use your image_gen tool to create the following image. Then save the "
        f"resulting PNG to this absolute path: {output}\n"
        "After saving, run `ls -la <path>` to verify the file exists.\n"
        f"{ref_note}\n"
        f"Image specification:\n{prompt}\n"
    )
    if extras:
        wrapped += "\n" + "\n".join(extras) + "\n"

    cmd: list[str] = [
        "codex",
        "exec",
        "--dangerously-bypass-approvals-and-sandbox",
        "--skip-git-repo-check",
    ]
    if reference:
        # -i / --image takes nargs=*; must be followed by `--` to terminate
        # before the positional prompt argument, otherwise the prompt is
        # consumed as another image filename. `reference` may be a single
        # Path or a list of Paths (canvas template + character portrait).
        ref_list = reference if isinstance(reference, list) else [reference]
        cmd.append("-i")
        cmd.extend(str(p) for p in ref_list)
        cmd.append("--")
    cmd.append(wrapped)

    logger.info("[backend:codex] $ codex exec ... (output=%s)", output)
    try:
        proc = subprocess.run(cmd, check=False, capture_output=True, timeout=420)
        if proc.returncode != 0:
            logger.error("[backend:codex] failed exit %d", proc.returncode)
            if proc.stderr:
                logger.error("%s", proc.stderr.decode(errors="replace")[-1000:])
            return proc.returncode
        if not output.exists() or output.stat().st_size == 0:
            logger.error("[backend:codex] codex exit 0 but %s missing/empty", output)
            if proc.stdout:
                logger.error("%s", proc.stdout.decode(errors="replace")[-1000:])
            return 5
        return 0
    except subprocess.TimeoutExpired:
        logger.error("[backend:codex] timed out after 420s")
        return 124


# ---------------------------------------------------------------------------
# Nano Banana dispatch
# ---------------------------------------------------------------------------
def generate_via_nano_banana(
    prompt: str,
    output: Path,
    aspect_ratio: str = "1:1",
    reference: Path | None = None,
    seed: int = 0,
    model: str = "pro",
) -> int:
    """Shell out to nano-banana-generate.py. Returns exit code."""
    script = find_nano_banana_script()
    if script is None:
        logger.error("[backend:nano-banana] nano-banana-generate.py not found at expected paths")
        return 127

    output.parent.mkdir(parents=True, exist_ok=True)

    if reference:
        cmd = [
            sys.executable,
            str(script),
            "with-reference",
            "--prompt",
            prompt,
            "--reference",
            str(reference),
            "--output",
            str(output),
            "--model",
            model,
            "--aspect-ratio",
            aspect_ratio,
        ]
    else:
        cmd = [
            sys.executable,
            str(script),
            "generate",
            "--prompt",
            prompt,
            "--output",
            str(output),
            "--model",
            model,
            "--aspect-ratio",
            aspect_ratio,
        ]

    logger.info(
        "[backend:nano-banana] $ %s (%s)",
        script.name,
        "with-reference" if reference else "generate",
    )
    try:
        subprocess.run(cmd, check=True, timeout=300)
        return 0
    except subprocess.CalledProcessError as e:
        logger.error("[backend:nano-banana] failed exit %d", e.returncode)
        return e.returncode
    except subprocess.TimeoutExpired:
        logger.error("[backend:nano-banana] timed out after 300s")
        return 124


# ---------------------------------------------------------------------------
# Subcommand wrappers
# ---------------------------------------------------------------------------
def cmd_generate_portrait(args: argparse.Namespace) -> int:
    if args.dry_run:
        logger.info("[backend] DRY-RUN: skipping backend call (portrait)")
        return 0
    try:
        choice = select_backend()
    except BackendUnavailableError as e:
        logger.error("%s", e)
        return 3
    logger.info("[backend] selected=%s (%s)", choice.backend, choice.detected_via)

    prompt = read_prompt(args.prompt, Path(args.prompt_file) if args.prompt_file else None)
    output = Path(args.output)

    if choice.backend == "codex":
        return generate_via_codex(prompt, output, aspect_ratio="4:5", seed=args.seed)
    return generate_via_nano_banana(prompt, output, aspect_ratio="4:5", seed=args.seed)


def cmd_generate_character(args: argparse.Namespace) -> int:
    if args.dry_run:
        logger.info("[backend] DRY-RUN: skipping backend call (character reference)")
        return 0
    try:
        choice = select_backend()
    except BackendUnavailableError as e:
        logger.error("%s", e)
        return 3
    logger.info("[backend] selected=%s (%s)", choice.backend, choice.detected_via)

    prompt = read_prompt(args.prompt, Path(args.prompt_file) if args.prompt_file else None)
    output = Path(args.output)

    if choice.backend == "codex":
        return generate_via_codex(prompt, output, aspect_ratio="1:1", seed=args.seed)
    return generate_via_nano_banana(prompt, output, aspect_ratio="1:1", seed=args.seed)


def cmd_generate_spritesheet(args: argparse.Namespace) -> int:
    if args.dry_run:
        logger.info("[backend] DRY-RUN: skipping backend call (spritesheet)")
        return 0
    try:
        choice = select_backend()
    except BackendUnavailableError as e:
        logger.error("%s", e)
        return 3
    logger.info("[backend] selected=%s (%s)", choice.backend, choice.detected_via)

    prompt = read_prompt(args.prompt, Path(args.prompt_file) if args.prompt_file else None)
    output = Path(args.output)
    canvas = Path(args.canvas) if args.canvas else None
    reference = Path(args.reference) if args.reference else None

    # Codex backend: pass BOTH images when both exist (canvas template +
    # character portrait). Codex `-i` accepts nargs=*; the model uses the
    # canvas for structural cell layout and the portrait for character
    # identity. Nano Banana single-ref API falls back to canvas-only.
    if choice.backend == "codex":
        refs: list[Path] = [p for p in (canvas, reference) if p]
        ref_arg: Path | list[Path] | None = refs if len(refs) > 1 else (refs[0] if refs else None)
        return generate_via_codex(prompt, output, reference=ref_arg, seed=args.seed)
    structural_ref = canvas or reference
    return generate_via_nano_banana(prompt, output, reference=structural_ref, seed=args.seed)


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------
def _add_common_args(parser: argparse.ArgumentParser) -> None:
    grp = parser.add_mutually_exclusive_group(required=True)
    grp.add_argument("--prompt", help="Prompt text")
    grp.add_argument("--prompt-file", help="Path to a file containing the prompt")
    parser.add_argument("--output", required=True, help="Output PNG path")
    parser.add_argument("--seed", type=int, default=0, help="Reproducibility seed")
    parser.add_argument("--dry-run", action="store_true", help="Skip backend call (smoke testing)")


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = parser.add_subparsers(dest="cmd", required=True)

    gp = sub.add_parser("generate-portrait", help="Single portrait image (Phase A portrait)")
    _add_common_args(gp)
    gp.set_defaults(func=cmd_generate_portrait)

    gc = sub.add_parser("generate-character", help="Phase A: reference character (spritesheet mode)")
    _add_common_args(gc)
    gc.set_defaults(func=cmd_generate_character)

    gs = sub.add_parser("generate-spritesheet", help="Phase C: spritesheet generation")
    _add_common_args(gs)
    gs.add_argument("--canvas", help="Phase B grid canvas template path")
    gs.add_argument("--reference", help="Reference character path (Phase A output)")
    gs.set_defaults(func=cmd_generate_spritesheet)

    return parser


def main(argv: list[str] | None = None) -> int:
    if not logging.getLogger().handlers:
        logging.basicConfig(
            level=logging.INFO,
            format="[%(name)s] %(levelname)s: %(message)s",
            stream=sys.stderr,
        )
    parser = build_parser()
    args = parser.parse_args(argv)
    return args.func(args)


if __name__ == "__main__":
    sys.exit(main())
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 321kUpdated 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: 197kUpdated 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