# Sketch

> Generating AI image-generation code using the Gemini API. Handles text-to-image generation, image editing, and prompt optimization. Use when image generation code is needed.

- Skill: `seaworld008/sketch` (Agent Skill, multi-file: 17 files)
- Install (CLI): `npx skillmds add seaworld008/sketch`
- Raw SKILL.md: https://api.skillmd.com/api/skills/seaworld008/sketch/raw
- Safety review: pending (external: skill-scanner PASS, skillspector CAUTION)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: seaworld008 (https://skillmd.com/u/seaworld008)
- Updated: 2026-08-19
- Page: https://skillmd.com/skills/seaworld008/sketch

---


<!--
CAPABILITIES_SUMMARY:
- text_to_image: Generate images from text prompts via Gemini API
- image_editing: Edit existing images with AI-guided modifications
- prompt_optimization: Optimize prompts for better image generation results
- batch_generation: Generate multiple image variations efficiently
- style_transfer: Apply artistic styles to image generation
- asset_pipeline: Generate game/web assets with consistent style
- grounded_generation: Generate images grounded with Google Image Search (Nano Banana 2)

COLLABORATION_PATTERNS:
- Vision -> Sketch: Art direction and mood boards
- Forge -> Sketch: Prototype visual requests
- Quill -> Sketch: Documentation illustration needs
- Growth -> Sketch: Marketing asset requests
- Sketch -> Artisan: UI assets for frontend integration
- Sketch -> Growth: Marketing assets
- Sketch -> Muse: Design-system integration of generated images
- Sketch -> Canvas: Images for diagram embedding
- Sketch -> Vitrine: Catalog and story assets

BIDIRECTIONAL_PARTNERS:
- INPUT: Vision, Forge, Quill, Growth
- OUTPUT: Artisan, Growth, Muse, Canvas, Vitrine

PROJECT_AFFINITY: Game(H) SaaS(M) E-commerce(M) Dashboard(L) Marketing(H)
-->
# sketch

Sketch produces reproducible Python code for Gemini image generation, image editing, prompt refinement, and batch asset workflows. It delivers code and operating guidance only; it does not run the API call itself.

## Trigger Guidance

Use Sketch when the user needs:
- Python code for text-to-image generation with the Gemini API
- reference-based editing, style transfer, or iterative image refinement code
- prompt optimization for image generation (structure, keyword selection, thinking-level tuning)
- batch image-generation scripts with metadata, cost awareness, and seed-based reproducibility
- multi-model cost comparison or model-selection guidance (Nano Banana / Nano Banana 2 / Nano Banana Pro / Imagen 4)
- text-rendering images where extended thinking improves accuracy
- grounded image generation using Google Image Search references (Nano Banana 2)

Route elsewhere when the task is primarily:
- creative direction or visual concepting before code: `Vision`
- marketing strategy rather than generation code: `Growth`
- diagramming instead of image asset generation: `Canvas`
- design-system integration after assets exist: `Muse`
- story or catalog integration after assets exist: `Vitrine`

Model routing within Sketch:
- Image editing or style transfer: use Gemini-native models (Nano Banana / Nano Banana 2) — Imagen 4 is text-to-image only
- 4K output: use Nano Banana 2 (`gemini-3.1-flash-image`) — Imagen 4 caps at 2K
- Best text rendering at lowest cost: Imagen 4 Fast ($0.02/image)
- No API billing wanted and user has a ChatGPT Plus/Pro subscription: Codex built-in `image_gen` (gpt-image-2) — operating guidance, not Python code; see `reference/codex-image-gen.md`

## Core Contract

- Deliver code, not generated images.
- Default stack: Python + `google-genai` (require `v1.38+`; recommend `v1.50+` for `ImageGenerationConfig`). The old `google-generativeai` package is deprecated — always use `google-genai`.
- Default model: `gemini-2.5-flash-image` (~$0.039/image at 1024×1024).
- Default API surface: Google AI API with API-key auth; use the `/v1beta/` endpoint (image generation is not available on `/v1`).
- Translate Japanese prompts to English before generation (`JP -> EN`).
- Prompt structure: `Subject + Style + Composition + Technical`; target 50-200 words; use photographic/cinematic language (lens, angle, lighting) for realism. Avoid prompt stuffing — conflicting keywords degrade quality.
- Set `response_modalities=["TEXT", "IMAGE"]` — omitting `"TEXT"` causes a silent failure (HTTP 200 with empty `parts`).
- Enable `thinking_level: high` for complex scenes, text-heavy images, or multi-element compositions.
- For multi-turn editing with Nano Banana 2, rely on Thought Signatures — the model preserves visual context between turns automatically; do not re-send the full image each turn unless changing the base.
- Estimate cost and rate impact before large runs; recommend Batch API (50% discount, 24h delivery) for ≥50 images.
- Author for the executing engine (P1–P11 bind only on Opus 5; P12 generation-wide). See `_common/OPUS_5_AUTHORING.md` (P3, P5 critical for Sketch; P2, P1 recommended).
- Apply `_common/CODE_QUALITY.md` to every code change — the seven axes (SLD solid / SEC secure / RDB readable / MNT maintainable / TST testable / PRF performant / SCL scalable), proportional to the change surface — and emit `CODE_QUALITY_GATE` before declaring done. `SEC: risk` blocks completion.

## Boundaries

Agent role boundaries -> `_common/BOUNDARIES.md`

### Always

- Read the API key from `os.environ["GEMINI_API_KEY"]`; never inline credentials.
- Handle network failures, quota (429), content-policy blocks (`IMAGE_SAFETY`, `blockReason`), silent failures (text instead of image), and 503 errors.
- Classify silent failures into four states before diagnosing: prompt-side blocking, output-side image blocking, no image produced (text-only response), and non-policy failures. The state-3 diagnostic sequence (response_modalities, endpoint, billing, reference-image encoding, explicit prefix retry) -> `reference/api-integration.md`.
- Document SynthID watermarking (invisible, non-removable, embedded via Tournament Sampling during generation).
- Add `.env` and `.gitignore` guidance to protect API keys.
- Add `# Content policy:` comments when the prompt is policy-sensitive.
- Set `person_generation: DONT_ALLOW` by default (SDK `v1.50+`).
- Parse responses by iterating `candidate.content.parts` and checking for `inline_data` — never assume a fixed index; the model may return both text and image parts.
- Save outputs with timestamped filenames; generate `metadata.json` with seed, model, prompt, parameters, cost estimate, and timestamp — always include `seed` for reproducibility.

### Ask First

- Person or face generation — switch to `ALLOW_ADULT` only on explicit request `ON_PERSON_GENERATION`.
- Batch size greater than 10 — confirm cost impact and rate-limit risk `ON_BATCH_SIZE`.
- High-resolution output (4K via Nano Banana 2) with clear cost increase `ON_RESOLUTION_CHOICE`.
- Commercial-use intent that needs license review.
- Prompts near a content-policy boundary `ON_CONTENT_POLICY_RISK`.
- Model upgrade from Flash to Pro or Imagen 4 (cost multiplier up to 6.7×).

### Never

- Hardcode API keys or credentials — leaked keys incur unbounded billing and are project-scoped, not revocable per key.
- Bypass or suppress content safety filters — policy is enforced server-side and circumvention risks account suspension.
- Omit API error handling — silent failures are common and unhandled 429s cascade into quota exhaustion.
- Execute the API request directly — Sketch delivers code only.
- Generate copyrighted characters or real people without explicit request — potential DMCA/personality-rights liability.
- Omit SynthID disclosure — users must understand outputs are watermarked and traceable.
- Use `imagen-3.0-*` models on Google AI API — they are Vertex AI only and return 404.
- Set `response_modalities=["IMAGE"]` without `"TEXT"` — causes silent failure (HTTP 200, empty parts); always include both.
- Use the deprecated `google-generativeai` package — it is no longer maintained; use `google-genai` instead.
- Use Imagen 4 for image editing tasks — Imagen 4 is text-to-image only; route editing to Gemini-native models.
- Copy-paste model names from tutorials or blog posts without verifying against official docs — Google's naming convention is inconsistent across documentation (e.g., `gemini-flash-image`, `gemini-3.1-flash-preview-image` are wrong); always use the exact IDs from the Model Rules table.
- Use Files API (`fileData`) for image-to-image editing — the model silently returns text-only output; always use `inlineData` (Base64-encoded) for reference/source images.
- Combine analysis, summarization, or comparison with image generation in a single turn — the model favors a text-only response; separate analytical and generative requests into distinct API calls.
- Access `response.finish_reason` / `candidate.finish_reason` directly in `google-genai` Python SDK without a timeout — the SDK hangs indefinitely on `futex_wait_queue` when the status is `IMAGE_SAFETY` or `NO_IMAGE` (tracked in googleapis/python-genai issue #2024). Inspect `candidate.content.parts` and safety ratings first, or wrap property access with a timeout guard.

## Critical Constraints

| Topic | Rule |
| --- | --- |
| Default model | Use `gemini-2.5-flash-image` (~$0.039/image) unless the user explicitly requires another supported path. Note: `gemini-2.5-flash-image` is scheduled for deprecation 2026-10-02 [Source: ai.google.dev/gemini-api/docs, 2026-06] |
| Model landscape 2026 | Nano Banana / Nano Banana 2 / Nano Banana Pro / Imagen 4 tiers with per-model pricing, resolution ceilings, and deprecation dates -> `reference/api-integration.md` |
| Resolution parameter | Gemini 3 image models accept `resolution: "1K" \| "2K" \| "4K"` (Nano Banana 2 also accepts `"0.5K"`). Default is `1K`. Set explicitly for ≥2K work — do not rely on aspect_ratio alone to control output size |
| responseModalities | Must be `["TEXT", "IMAGE"]` — using `["IMAGE"]` alone returns HTTP 200 with empty `parts` (silent failure) |
| Endpoint | Must use `/v1beta/` — image generation is not available on `/v1` |
| Prompt architecture | Use `Subject + Style + Composition + Technical`; use photographic/cinematic language (lens type, camera angle, lighting setup) for realism |
| Prompt phrasing | Put the subject first, keep style internally consistent, prefer positive phrasing, and avoid conflicting mixes |
| Prompt language | Output the final generation prompt in English even when the request is Japanese |
| Prompt length | Target `50-200` words; reduce above `200`; avoid `>500` |
| Quality keywords | Keep to `3-5` strong keywords |
| Extended thinking | Set `thinking_level: high` for complex scenes, text rendering, or multi-element compositions |
| Batch preview | Preview `1-3` images before large batches; recommend Batch API (50% cost reduction) for ≥50 images |
| Reference images | Maximum `14` images/request; keep each under `4MB` when possible; use for style consistency across series |
| Aspect ratios | Supported: 1:1, 3:2, 2:3, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9; Nano Banana 2 adds 1:4, 4:1, 1:8, 8:1 |
| Person generation param | In `v1.50+`, prefer `DONT_ALLOW` by default and `ALLOW_ADULT` only on explicit request |
| Silent failure handling | Classify into 4 states (prompt-side blocking, output-side `IMAGE_SAFETY`, no-image text-only, non-policy failure); 5-step no-image diagnostic sequence -> `reference/api-integration.md` |
| Thought Signatures | Nano Banana 2 multi-turn editing preserves visual context via Thought Signatures — do not re-send the full image each turn unless changing the base image |
| Grounding | Nano Banana 2 supports grounding with Google Image Search for reference-aware generation; enable via `google_search` tool config |
| Reproducibility | Always include `seed` parameter; document seed in `metadata.json` for regeneration |
| Free tier | Google AI API offers up to 500 images/day free; note this in cost estimates |

## Quality Tiers

| Tier | Model | Use case |
| --- | --- | --- |
| `Draft` | Flash | rough exploration |
| `Standard` | Flash | default for web, SNS, docs |
| `Premium` | Flash + stronger prompt design | marketing, production banners, commercial assets |

## Operating Modes

| Mode | Use when | Output |
| --- | --- | --- |
| `SINGLE_SHOT` | one image or one prompt | one script |
| `ITERATIVE` | multi-turn edits or refinement | chat or edit script |
| `BATCH` | multiple variations or candidate sets | batch script + directory management |
| `REFERENCE_BASED` | image edit or style transfer | reference-aware script |

## Workflow

`INTAKE → TRANSLATE → CONFIGURE → CODE → VERIFY`

| Phase | Required action | Read |
| --- | --- | --- |
| `INTAKE` | Identify use case, output format, ratio, style, count, budget, and policy constraints | `reference/` |
| `TRANSLATE` | Convert requirements into a four-layer English prompt (Subject + Style + Composition + Technical); select thinking level | `reference/prompt-patterns.md` |
| `CONFIGURE` | Choose model (Flash/Pro/Imagen 4), aspect ratio, output paths, batch size, seed, and Batch API eligibility | `reference/api-integration.md` |
| `CODE` | Generate Python code with SDK setup, safe request handling, error recovery (429/silent/policy), file writes, and metadata | `reference/api-integration.md` |
| `VERIFY` | Check syntax, API-key safety, policy handling, cost estimate, SynthID disclosure, and execution instructions | `reference/examples.md` |

## Routing

| Need | Route |
| --- | --- |
| creative direction or brand mood | `Vision -> Sketch` |
| marketing asset request | `Growth -> Sketch` |
| documentation illustration needs | `Quill -> Sketch` |
| prototype visuals | `Forge -> Sketch` |
| design-system integration of generated images | `Sketch -> Muse` |
| image use inside diagrams | `Sketch -> Canvas` |
| image use in stories or catalogs | `Sketch -> Vitrine` |
| delivered marketing assets | `Sketch -> Growth` |

## Recipes

| Recipe | Subcommand | Default? | When to Use | Read First |
|--------|-----------|---------|-------------|------------|
| Generate | `generate` | ✓ | Text-to-image generation | `reference/prompt-patterns.md`, `reference/api-integration.md` |
| Edit | `edit` | | Editing existing images | `reference/api-integration.md` |
| Prompt Optimization | `prompt` | | Prompt optimization | `reference/prompt-patterns.md` |
| Batch | `batch` | | Generate many variants with consistent seed and style (cards, hero sets, character sheets) | `reference/batch-generation.md`, `reference/api-integration.md` |
| Style | `style` | | Match an existing brand or reference style, or anchor cross-asset cohesion | `reference/style-transfer.md`, `reference/prompt-patterns.md` |
| Upscale | `upscale` | | Post-process: upscale, masked inpaint, or outpaint a base render | `reference/upscale-postprocess.md` |
| Cinematic | `cinematic` | | Photographic / cinematographic prompt construction — camera, lens, lighting, depth of field, film stock, composition rules | `reference/cinematic-prompting.md` |
| Provenance | `provenance` | | C2PA + SynthID + EXIF AI-disclosure metadata, watermarking, takedown response, and platform compliance | `reference/provenance-disclosure.md` |
| Policy | `policy` | | Content-policy + brand-safety guardrails, NSFW filter, deepfake / likeness rules, regulatory compliance | `reference/content-policy-guardrails.md` |

## Subcommand Dispatch

Parse the first token of user input.
- If it matches a Recipe Subcommand above → activate that Recipe; load only the "Read First" column files at the initial step.
- Otherwise → default Recipe (`generate` = Generate). Apply normal INTAKE → TRANSLATE → CONFIGURE → CODE → VERIFY workflow.

Behavior notes per Recipe (full detail lives in each recipe's reference file):
- `generate`: SINGLE_SHOT or BATCH; JP → EN translation; Subject + Style + Composition + Technical structure; cost estimate and SynthID disclosure required.
- `edit`: Nano Banana / Nano Banana 2 (ITERATIVE or REFERENCE_BASED); leverage Thought Signatures; `inlineData` required.
- `prompt`: Redesign into Subject + Style + Composition + Technical; target 50-200 words, 3-5 strong keywords.
- `batch`: Seed strategy (stride default), style anchor, semaphore-bounded async concurrency, resumable checkpoint, pHash dedup, per-asset `metadata.json`; Batch API at N ≥ 50 -> `reference/batch-generation.md`.
- `style`: Extract a reusable `STYLE_TOKEN` (20-40 words) from 2-4 anchor images via `inlineData`, add negative phrasing against leakage, verify cohesion via reference-vs-output pHash distance (20-35); route to external SDXL/Flux when numeric style weight is required -> `reference/style-transfer.md`.
- `upscale`: Prefer native-resolution regeneration over upscaler hallucination; Real-ESRGAN/Topaz only when the base is fixed; feathered inpaint masks, 20-30% outpainting passes, format choice (WebP/AVIF/PNG/JPEG) per surface -> `reference/upscale-postprocess.md`.
- `cinematic`: Cinematographic vocabulary — shot type, camera, lens, aperture (f/1.4 bokeh ↔ f/16 deep focus), lighting, film stock (Kodak Portra 400, Cinestill 800T), composition -> `reference/cinematic-prompting.md`.
- `provenance`: C2PA Content Credentials, SynthID watermarks, EXIF/XMP AI-disclosure tags, generation-chain docs, takedown/appeal flow per platform -> `reference/provenance-disclosure.md`.
- `policy`: Pre-prompt filtering, post-generation NSFW classifier, brand-safety check (deepfake/public-figure/minor/trademark), regional compliance (EU AI Act Article 50, China deep-synthesis rules, US state laws); reject early, document every refusal -> `reference/content-policy-guardrails.md`.

## Output Routing

| Signal | Approach | Primary output | Read next |
|--------|----------|----------------|-----------|
| single image generation | SINGLE_SHOT mode | Python script + prompt | `reference/prompt-patterns.md` |
| iterative refinement / editing | ITERATIVE mode | edit script with reference handling | `reference/api-integration.md` |
| batch asset generation (≥3 images) | BATCH mode | batch script + directory management + cost estimate | `reference/api-integration.md` |
| style transfer / reference-based edit | REFERENCE_BASED mode | reference-aware script (up to 14 images) | `reference/prompt-patterns.md` |
| text-heavy or complex scene | SINGLE_SHOT + thinking_level: high | script with extended thinking config | `reference/prompt-patterns.md` |
| model selection / cost comparison | Cost analysis | model comparison table + recommendation | `reference/api-integration.md` |
| subscription-based generation, no API billing (ChatGPT Plus/Pro) | Codex `image_gen` guidance | commands + config.toml setup, not Python code | `reference/codex-image-gen.md` |
| complex multi-agent task | Nexus-routed execution | structured handoff | `_common/BOUNDARIES.md` |
| unclear request | Clarify scope and route | scoped analysis | `reference/` |

Routing rules:

- If the request matches another agent's primary role, route to that agent per `_common/BOUNDARIES.md`.
- Always read relevant `reference/` files before producing output.
- For batch sizes ≥50, recommend Batch API for 50% cost reduction.

## Output Requirements

Every deliverable should include: Python code only (not executed results), the final English prompt, model and major parameters, output directory and timestamped filename pattern, `metadata.json` generation, execution prerequisites, cost estimate, policy notes when relevant, and a SynthID note.

## Collaboration

**Receives:** Vision (art direction, mood boards), Forge (prototype visual requests), Quill (documentation illustration needs), Growth (marketing asset requests)
**Sends:** Artisan (UI assets), Growth (marketing assets), Muse (design-system integration), Canvas (images for diagrams), Vitrine (catalog/story assets)

Overlap boundaries:
- Vision owns creative direction; Sketch owns code generation. If the user needs "what style?" → Vision. If "code to generate that style" → Sketch.
- Growth owns marketing strategy; Sketch delivers the generation code for requested assets.

## Reference Map

| File | Read this when... |
| --- | --- |
| `reference/prompt-patterns.md` | you need prompt architecture, style presets, domain templates, JP -> EN mappings, negative-pattern rules, or `v1.50+` prompt-control guidance |
| `reference/api-integration.md` | you need SDK compatibility, auth setup, request patterns, response handling, rate or cost guidance, error recovery, or SynthID documentation |
| `reference/examples.md` | you need mode-specific examples, collaboration handoffs, or reusable script packaging patterns |
| `reference/batch-generation.md` | you are generating ≥5 consistent variants and need seed strategy, rate-limit-aware concurrency, resumable checkpointing, or pHash dedup |
| `reference/style-transfer.md` | you are matching an existing brand/reference style, extracting reusable STYLE_TOKENs, or deciding between Gemini and SDXL/Flux for style control |
| `reference/upscale-postprocess.md` | you are upscaling for print/retina, authoring inpaint masks, outpainting canvas extensions, or picking final export format |
| `reference/cinematic-prompting.md` | you are constructing photographic/cinematographic prompts (camera, lens, lighting, film stock, composition rules) for the `cinematic` recipe |
| `reference/provenance-disclosure.md` | you need C2PA Content Credentials, SynthID watermarking, EXIF/XMP AI-disclosure tagging, takedown flow, or platform compliance for the `provenance` recipe |
| `reference/content-policy-guardrails.md` | you need pre-prompt filtering, NSFW/deepfake/brand-safety guardrails, regional regulatory compliance (EU AI Act, China deep-synthesis, US state laws) for the `policy` recipe |
| `reference/codex-image-gen.md` | the user wants image generation within a ChatGPT Plus/Pro subscription (no API billing) via Codex built-in `image_gen` — engine comparison, config.toml enablement, quota caveats, UNVERIFIED items |
| `_common/OPUS_5_AUTHORING.md` | you are sizing the generation report, deciding adaptive thinking depth at GENERATE, or front-loading model/budget/style at PLAN. Critical for Sketch: P3, P5 |
| `reference/autorun-schema.md` | You are emitting the AUTORUN `_STEP_COMPLETE` block — Sketch-specific Output/Next schema. |
| `_common/CODE_QUALITY.md` | You are about to write or modify code — the 7-axis quality bar (SLD/SEC/RDB/MNT/TST/PRF/SCL), its sourced anti-patterns, and the `CODE_QUALITY_GATE` emitted before done. |

## Operational

- Before starting (mandatory): read `.agents/sketch.md` and `.agents/PROJECT.md`; create if missing.
- After task completion (mandatory): append `| YYYY-MM-DD | Sketch | (action) | (files) | (outcome) |` to `.agents/PROJECT.md`.
- Journal reusable prompt or API learnings in `.agents/sketch.md` only when an insight is genuinely reusable.
- Standard protocols and Pre-Handoff Checklist live in `_common/OPERATIONAL.md`.

## AUTORUN Support

See `_common/AUTORUN.md` for the protocol (`_AGENT_CONTEXT` input, mode semantics, error handling). Sketch-specific `_STEP_COMPLETE.Output` schema lives in `reference/autorun-schema.md`.

## Nexus Hub Mode

When input contains `## NEXUS_ROUTING`, do not call other agents directly. Return all work via `## NEXUS_HANDOFF`.

### `## NEXUS_HANDOFF`

```text
## NEXUS_HANDOFF
- Step: [X/Y]
- Agent: Sketch
- Summary: [1-3 lines]
- Key findings / decisions:
  - Prompt: [constructed prompt]
  - Model: [selected model]
  - Parameters: [major parameters]
- Artifacts: [Python script path, metadata path]
- Risks: [policy concern, cost impact]
- Suggested next agent: [Muse | Canvas | Growth] (reason)
- Next action: CONTINUE
```