Communitygithub.com

evalix098/tiktoklive

Guía para usar las herramientas Imagine en Grok Build: imagine_text_to_image, imagine_image_to_image, imagine_reference_to_image, imagine_text_to_video, imagine_image_to_video, imagine_reference_to_video y render_file para vistas previas en chat. Cuándo crear un visual con código en lugar de generarlo, elaboración de prompts, manejo de referencia primero para personas reales, fundamentación factual y coherencia de activos. Cargar esto siempre que se considere generar o editar una imagen o video. Basado en uso de herramientas, no activado por un usuario que simplemente menciona imágenes.

¿Qué es tiktoklive?

La habilidad 'evalix098/tiktoklive' proporciona una guía completa y detallada para utilizar el conjunto de herramientas 'Imagine' dentro del ecosistema Grok Build. Está diseñada para desarrolladores y agentes de IA que necesitan generar o editar imágenes y videos de manera programática, enfatizando el uso correcto de herramientas específicas como `imagine_text_to_image`, `imagine_image_to_image`, `imagine_reference_to_image`, y sus contrapartes de video. La habilidad destaca la importancia de un manejo de rutas de archivos en un 'sandbox' compartido y el uso de `render_file` para mostrar resultados al usuario. Un principio clave es que, para contenido que requiere precisión textual, numérica o estructural (como gráficos, diagramas o tablas), es preferible construirlo con código (HTML/CSS) en lugar de usar modelos de imagen, que son poco fiables para esos casos. La habilidad también proporciona pautas para la elaboración de prompts, verificación de precisión en un bucle, manejo de personas reales (usando referencias primero) y principios de consistencia y manejo de fallos. Se aplica a cualquier plataforma que utilice el stack 'grok_computer' de Grok Build, y su carga debe estar basada en la intención del agente de usar una herramienta de generación visual, no simplemente por mención de imágenes.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/evalix098/tiktoklive/tree/HEAD/.grok/skills/imagine-grok-build

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Imagine

Grok Build utiliza el stack de computación Imagine dividido (variantes grok_computer). No existe una herramienta consolidada imagine_image o imagine_video — siempre llama al nombre específico de la modalidad de la tabla a continuación.

HerramientaRol
imagine_text_to_imageNueva imagen a partir de un prompt de texto únicamente (sin fuente).
imagine_image_to_imageEditar / cambiar el estilo de una imagen existente (ruta del sandbox).
imagine_reference_to_imageCombinar 2+ imágenes de referencia (rutas del sandbox).
imagine_text_to_videoNuevo video a partir de un prompt de texto únicamente (sin fuente).
imagine_image_to_videoAnimar una imagen fija (ruta del sandbox) en un video.
imagine_reference_to_videoVideo a partir de 1+ imágenes de referencia (rutas del sandbox).
render_fileMostrar una ruta de imagen/video del sandbox al usuario en el chat.

Manejadores basados en rutas. Estas herramientas leen/escriben en el sandbox compartido:

  • La generación devuelve un file_path del sandbox (en artifacts). Ábrelo con read_file / shell; muéstraselo al usuario con render_file.
  • Las herramientas de edición / animación toman esa ruta (o rutas) como entrada — coincide con el esquema en vivo (image, images, etc.). Nunca inventes rutas.
  • Nunca llames a imagine_image / imagine_video. Los ayudantes de ID de activos (imagine_create_asset / imagine_view_media / render_imagine_media) no están en este stack.

Aplica esto siempre que estés considerando o estés a punto de llamar a cualquiera de estas herramientas.

Flujo de manejo (modelo mental obligatorio)

generar → file_path → render_file (mostrar al usuario) / read_file o scripts (control de calidad)
editar / animar → pasar file_path(s) anteriores a image_to_* / reference_to_*
  • Usa la ruta que la herramienta realmente devolvió — no inventes rutas del sistema de archivos.
  • Muestra el material multimedia al usuario con render_file, no con enlaces de imagen markdown ad-hoc.

Construir imágenes precisas con código, no con las herramientas de imagen

  1. Los modelos de imagen no son fiables para texto exacto, números y estructura. Pueden manejar texto corto o un diseño simple, pero a menudo distorsionan palabras, inventan números, dibujan barras de gráficos que no coinciden con ningún dato, o apuntan flechas de diagramas a ninguna parte, y cuanto más tiene que ser exacto, peor lo hacen. Un prompt detallado no lo hace confiable, y otra edición de imagine_image_to_image normalmente no lo solucionará. Por lo tanto, cuando un resultado necesita texto, datos o estructura específicos para ser correctos (gráficos a partir de números reales, diagramas etiquetados o técnicos, explicaciones matemáticas, tablas, pantallas con texto real), construye el activo con código, donde controlas el contenido exacto. Prefiere HTML y CSS, que ofrecen un diseño, tipografía y acabado mucho mejores que los gráficos de Python. Cuando solo importa la apariencia (fotos, ilustraciones, personajes, escenas, arte decorativo), las herramientas de imagen son la opción correcta. Cuál se adapta depende de lo que la salida necesita acertar, no de cómo está redactada la solicitud.

Verificar la precisión discreta (bucle)

Cuando la salida debe acertar con texto, números, datos o estructura específicos, no confíes en el primer resultado — verifícalo en un bucle:

  1. Produce el resultado (genera, o según Construir imágenes precisas con código, constrúyelo en código).
  2. Inspecciona la salida real — usa read_file (comprensión de imágenes) en la ruta del resultado — y confirma que cada palabra, número, etiqueta y detalle estructural coincida con el requisito, y que nada se superponga, recorte o salga del lienzo.
  3. Si algo está mal, corrígelo y vuelve a verificar:
    • ¿Texto distorsionado, números inventados o diseño roto de un modelo de imagen? No vuelvas a hacer el prompt — probablemente lo distorsionará de nuevo. Reconstruye con código.
    • ¿Elementos superpuestos o recortados en la salida construida con código? Rediseña con diseño automático (HTML/CSS) en lugar de ajustar coordenadas manualmente.
    • De lo contrario, haz una edición específica a través de imagine_image_to_image con la ruta anterior.
  4. Solo termina cuando el contenido discreto sea exactamente correcto. Si no se puede hacer preciso, informa al usuario en lugar de enviar algo incorrecto.

Principios Básicos

  1. Tú eres dueño del prompt. Si el usuario da un prompt detallado o te pide que uses el suyo, úsalo textualmente. De lo contrario, elabora el prompt final: coloca el sujeto al principio, da una dirección general sólida para el estado de ánimo, composición, iluminación y estilo sin especificar cada detalle en exceso, escribe en prosa natural en lugar de etiquetas de palabras clave, y describe positivamente en lugar de usar prompts negativos. Para ediciones, describe solo lo que cambia. Apunta a 2-5 oraciones.
  2. Referencia primero para personas reales. Nunca uses texto a imagen puro para una persona o grupo real nombrado, incluyendo intercambios de rostros, carteles, caricaturas y representaciones cinematográficas o editoriales. Usa imagine_image_to_image con una ruta de referencia real en su lugar, y nunca produzcas imágenes no consensuadas, sexualizadas o que involucren a menores. Consulta Personas Reales y Referencias para el procedimiento.
  3. Fundamenta los hechos con búsqueda primero. Si alguna parte de la solicitud depende de un hecho del mundo real, identidad, marca o producto, lugar, evento, o resultado superior/último/actual, busca en la web antes de generar y pon los detalles verificados reales en el prompt. No confíes en la memoria, y no escribas marcadores de posición vagos como "el presidente actual"; escribe el nombre verificado.
  4. Reutiliza una base para la consistencia. Cuando el mismo personaje, objeto o escenario debe aparecer en múltiples imágenes, genera una base con imagine_text_to_image, guarda su file_path, luego pasa esa ruta a imagine_image_to_image para cada variación. No vuelvas a ejecutar texto a imagen desde cero para un sujeto recurrente.
  5. Maneja los fallos con gracia. Ante un bloqueo de moderación o seguridad, detente; no lo reintentes ni parafrasees el prompt para evadir el filtro. Informa al usuario que fue bloqueado y ofrece una dirección diferente. Si una referencia es débil o un resultado parece fuera de lugar, dilo y pide una subida o redirección en lugar de iterar en silencio.
  6. Planifica flujos de trabajo de múltiples pasos. Secuencia los pasos; solo paraleliza generaciones que pertenezcan al mismo paso.
  7. Revisa al final. Confirma que las generaciones que pretendías realmente se ejecutaron y coinciden con lo solicitado. Renderiza los activos finales con render_file.
  8. No asumas el comportamiento de la herramienta. No inventes parámetros de herramientas, valores de retorno o capacidades del entorno que no estén realmente proporcionados; verifica en lugar de adivinar.

Elegir la herramienta

SituaciónLlama a
Nueva imagen, sin fuenteimagine_text_to_image con prompt (+ aspect_ratio)
Editar / cambiar estilo / recolorear una imagen existenteimagine_image_to_image con prompt + ruta de origen
Combinar 2+ imágenes de referencia en unaimagine_reference_to_image con prompt + rutas de origen
Iterar sobre un resultado anteriorimagine_image_to_image con ruta anterior
Persona o grupo real nombradoimagine_image_to_image con una ruta de referencia real después de búsqueda web
Sujeto genérico / inventado desde ceroimagine_text_to_image
Nuevo video, sin fuenteimagine_text_to_video con prompt
Animar una imagen fijaimagine_image_to_video con la ruta de esa imagen fija
Video multi-referenciaimagine_reference_to_video con ruta(s) de imagen

Regla general: sin referencias → text_to_; una referencia → image_to_; 2+ referencias → reference_to_*.

imagine_text_to_image

Genera una nueva imagen a partir de un prompt de texto.

Entradas:

  • prompt (obligatorio) - descripción completa de la imagen deseada.
  • aspect_ratio - uno de 1:1, 3:4, 4:3, 2:3, 3:2, 9:16, 16:9, 21:9, 5:2, 50:11, o unknown. Usa 16:9 para tarjetas de compartir OG y 50:11 para el banner del feed de X al generar un public/x-banner.jpg personalizado para juegos (cada aplicación conecta x:game:image; solo los juegos llaman a Imagine para ello — consulta la habilidad og); para un lienzo 2:1 real, llama a la API de xAI Images.

Para producir múltiples variaciones, haz múltiples llamadas a imagine_text_to_image con prompts distintos. La herramienta no expone parámetros n o count.

imagine_image_to_image

Edita una imagen existente.

Entradas (los nombres siguen el esquema en vivo — típicamente una ruta singular del sandbox):

  • prompt (obligatorio) - qué cambiar (describe solo la edición).
  • Campo de ruta de origen (obligatorio) - ruta del sandbox devuelta por una generación o descarga anterior.
  • aspect_ratio - solo se establece cuando el usuario quiere explícitamente un cambio de relación.

imagine_reference_to_image

Compone una imagen a partir de 2+ rutas de referencia.

Entradas:

  • prompt (obligatorio).
  • Rutas de origen (obligatorio) - 2+ rutas del sandbox.
  • aspect_ratio - opcional.

Para una edición de fuente única, usa imagine_image_to_image en su lugar.

imagine_text_to_video

Genera un nuevo video a partir de un prompt de texto únicamente (sin fotograma de origen).

Entradas:

  • prompt (obligatorio) - descripción corta de la toma en tiempo presente.
  • Campos de duration / aspect_ratio / resolución según lo expuesto por el esquema en vivo.

Prefiere tomas cortas; las mismas reglas de elaboración de prompts que para imagen a video a continuación.

imagine_image_to_video

Anima una imagen fija en un video.

Entradas:

  • Ruta de la imagen fija de origen singular (obligatorio).
  • prompt - toma corta en tiempo presente (recomendado; obligatorio en algunas variantes).
  • duration - 6 (predeterminado), 10, o 15 cuando se expone.
  • aspect_ratio - opcional; omítelo para mantener la relación de la fuente al animar una imagen.

Prefiere tomas cortas. Construye el video como una secuencia planificada de clips cortos, no como una sola toma larga:

  1. Planifica la historia en tomas - un ritmo cada una.
  2. Prefiere más tomas de 6s sobre menos tomas largas.
  3. Crea la imagen fija de origen de cada toma con imagine_text_to_image / imagine_image_to_image (mantén las rutas de los personajes consistentes).
  4. Anima con imagine_image_to_video + esa ruta de imagen fija.

Comportamientos clave:

  • Elaboración de prompts: un momento corto y vívido en tiempo presente con un movimiento de cámara claro, en 1-2 oraciones.
  • Mínimo pero interesante: un sujeto claro y un solo movimiento simple o movimiento de cámara.
  • ¿Fuente compleja? Mantén el sujeto fijo y mueve solo la cámara, o divídelo en tomas más simples.
  • Personas reales: referencia primero - conduce desde una referencia verificada; nunca animes a una persona nombrada sin una.
  • No bucles el mismo clip a menos que se te pida.
  • Ensambla líneas de tiempo de múltiples tomas con copia de flujo de FFmpeg en las rutas de video devueltas.

imagine_reference_to_video

Video a partir de una o más rutas de imágenes de referencia guiado por un prompt. Prefiere componer una sola imagen fija con imagine_reference_to_image primero, luego imagine_image_to_video, cuando el objetivo sea un primer fotograma limpio.

Escribir Prompts Fuertes

Describe, aproximadamente en este orden: sujeto -> acción/pose -> entorno -> estilo -> composición -> iluminación/ambiente -> detalles clave.

  • Sé específico y concreto; lidera con los elementos más importantes.
  • Indica qué incluir en lugar de qué excluir.
  • Usa una escena coherente por prompt.
  • Empareja aspect_ratio con el caso de uso: 9:16 para teléfono/historia, 16:9 para banner/marco de video o tarjetas de compartir OG, 1:1 para avatar/icono.

Personas Reales y Referencias

  1. Busca en la web primero para confirmar identidad, rol, relación o evento, incluso cuando parezca obvio.
  2. Obtén una imagen de referencia sólida en disco (subida del usuario o búsqueda → ruta del sandbox), luego llama a imagine_image_to_image con esa ruta. Una foto subida por el usuario es la mejor.
  3. Si no existe una referencia adecuada, pide al usuario que suba una en lugar de generar a partir de una base débil.

Mostrar resultados

  • Llama a render_file con el file_path del sandbox para que el usuario vea la imagen/video en el chat.
  • Para tu propio control de calidad y scripts, read_file / shell en esa ruta.

Los sprites y mapas de juegos tienen sus propios pipelines — sigue generate2dsprite, video2dsprite y generate2dmap para esos.

Modos de fallo a evitar

  • Llamar a nombres consolidados imagine_image o imagine_video (no están disponibles).
  • Pasar una lista a imagine_image_to_image / imagine_image_to_video (fuente singular únicamente).
  • Inventar una ruta del sistema de archivos que la herramienta nunca devolvió.
  • Ejecutar chroma/ffmpeg en una ruta que inventaste sin una generación real/file_path.

Individual skills in this repo

This repo contains 17 individual skills — each has its own dedicated page.

evalix098/tiktoklive

Add user accounts and sign-in to this TanStack Start app. Use when the app needs authentication, sign-in, user accounts, protected routes, or per-user data. Triggers on "auth", "login", "log in", "sign in", "sign up", "account", "users", "authentication", "protected", "who is logged in", "current user", "per-user".

evalix098/tiktoklive

Build browser games and interactive/canvas/3D experiences in this TanStack Start + React app. Use for any game, simulation, or WebGL/Canvas experience — 2D or 3D, single-player. Covers the game loop & timing, 3D orientation/camera conventions, collision, performance, assets, audio, save, game feel, and per-genre playbooks. For WASD / vehicle / flight **input signs and inverted A/D**, open the **`controls`** skill — do not rely on this file or racing-kart alone. Triggers on "game", "minecraft", "fps", "platformer", "racing", "tetris", "snake", "shooter", "3d", "three.js", "canvas", "voxel", "physics".

evalix098/tiktoklive

Player-facing input signs for browser games: WASD, vehicles, flight, FPS mouse-look, and the #1 failure mode (inverted A/D). Mandatory control self-tests and a tiny test interface so you can verify A turns left before shipping. Load for ANY game with movement, steering, flying, driving, tanks, boats, mechs, drones, planes, karts, third-person follow cams — not only racing. Triggers on "controls", "WASD", "inverted", "steer", "flight", "airplane", "kart", "vehicle", "yaw", "roll", "pitch", "mouse look", "A/D".

evalix098/tiktoklive

Design and build polished, non-generic UI for this TanStack Start + React + Tailwind v4 + shadcn/Radix app. Use whenever you create or restyle any interface surface — pages, landing pages, dashboards, forms, modals, nav, and game overlays (start screens, HUD, menus). Covers design tokens, layout, typography, color, spacing, motion, and the anti-"AI-slop" rules that keep output from looking generic. Triggers on "design", "UI", "make it look good", "polish", "landing page", "theme", "style", "redesign", "ugly", "clean up".

evalix098/tiktoklive

Deep guide for game ANIMATION assets: motion cycles, action keyframes, effect sequences, and animation sprite sheets — built around a video-first pipeline. In this app-builder sandbox, execute via the video2dsprite / generate2dsprite skills (magenta + scripts), not ad-hoc ffmpeg. Use whenever generating anything that moves: walk/run cycles, attacks, idles, FX, flags, fire, animation sheets. Complements game-asset-core.

evalix098/tiktoklive

Core discipline for ANY game-asset generation with Imagine tools: the engine-ready defaults users don't state, spec checklists, style anchoring, read-back verification, honest defect flagging. Use whenever generating any game art (sprites, sheets, animations, tiles, UI, FX) — then ALSO load the matching specialist skill: game-animation-frames for anything that moves, game-tilesets for tiles/terrain, game-character-consistency for recurring characters, game-ui-icons for UI and icons.

evalix098/tiktoklive

Deep guide for CHARACTER IDENTITY across images: turnarounds (front/side/ back), state and damage variants, palette swaps, equipment changes, and same-character-in-context sets. Use whenever generating character turnarounds, character sheets, variants of an existing sprite, or any same-subject multi-image set. Complements game-asset-core.

evalix098/tiktoklive

Deep guide for game TILE assets: seamless tileable textures, terrain transition tilesets, autotiles, and ground/platform tiles. Use whenever generating tileable textures, tilesets, terrain transitions, or seamless patterns. Complements game-asset-core.

evalix098/tiktoklive

Deep guide for game UI assets: buttons with interaction states, panels, bars, wordmark logos, and icon sets. Use whenever generating game UI elements, HUD assets, inventory icons, icon sets, buttons, or title logos. Complements game-asset-core.

evalix098/tiktoklive

Generate production-oriented 2D game maps with `imagine_text_to_image`: RPG/top-down maps, side-scroller parallax stages, tilemaps, layered raster maps, prop packs, collision zones, and walkable areas. Use when building browser games that need real map art (not pure code-drawn tiles), layered props, or map collision metadata. Triggers on "map", "level", "stage", "tilemap", "overworld", "dungeon", "side scroller background", "prop pack", "2D map".

evalix098/tiktoklive

Generate and postprocess 2D game sprites and animation sheets: pixel-art characters, NPCs, creatures, spells, projectiles, impacts, props, summons, and transparent PNG/GIF exports. Use when building browser games that need real sprite sheets (not code-drawn placeholders), matching a map art style, or producing magenta-background sheets for chroma-key cleanup. Triggers on "sprite", "sprite sheet", "animation sheet", "pixel art character", "walk cycle", "attack animation", "projectile sprite", "2D game asset".

evalix098/tiktoklive

Peer-to-peer realtime multiplayer over WebRTC data channels: every user of the deployed app connects directly to every other user (full mesh), the server only brokers the handshake at /api/rtc. Lowest possible latency, zero per-message server cost. Use for 2-8 player co-op/casual realtime: shared cursors, drawing, party games, casual action. Triggers: p2p, peer to peer, webrtc, low latency multiplayer, direct connection.

evalix098/tiktoklive

Use Neon Postgres (the database) in this TanStack Start app. Use when the app needs to store or query data, persist state, or keep per-user data. Triggers on "database", "Postgres", "Neon", "save data", "store data", "persist", "tables", "SQL", "query", "migrations".

evalix098/tiktoklive

Share-link previews and app identity for apps on *.grok.me: the injector-owned og:image card, the SVG favicon, and PWA icons for installable apps. Use when scaffolding, renaming, or restyling the app — and for share / unfurl / OG / Twitter card questions. A custom 1200×630 card from the app's own art is the default — games of every kind (DOM board/word games included), whimsical apps, creative tools, and brand-forward pages; only plain utilities keep the placeholder. Always run the brand-asset pass as a `task` subagent and never wait for it. Triggers on "share", "rename", "app name", "OG", "Open Graph", "twitter card", "unfurl", "og:image", "og:type", "x:game:image", "x-banner", "link preview", "social card", "thumbnail", "preview image", "favicon", "app icon", "PWA", "manifest", "installable", "home screen", "SEO", "meta description".

evalix098/tiktoklive

Official Three.js API and TSL (Three.js Shading Language) reference for LLM code generation. Load when writing or debugging three.js / WebGL / WebGPU / custom materials / shaders / GLTF / advanced three APIs beyond basic game loop/controls. Prefer building-games for game correctness (loop, WASD, camera, orientation); use this skill for full API/TSL depth. Triggers on "three.js", "threejs", "WebGPU", "TSL", "NodeMaterial", "shader", "GLTF", "MeshStandard", "OrbitControls", "WebGLRenderer".

evalix098/tiktoklive

Grok Build only. Turn a 2D character still into denser animation sprites via imagine_text_to_image base → imagine_image_to_video (6s/10s run-in-place) → ffmpeg frames → magenta chroma-key → dense sampled strips/grids/GIFs. Use when the user wants video-to-sprite, smoother run/walk cycles, or denser intermediate poses. Prefer generate2dsprite for crisp production pixel sheets. Triggers on "video to sprite", "imagine_image_to_video sprite", "dense walk cycle", "smooth run animation from video".

evalix098/tiktoklive

Call the xAI API (Grok) from this app's server code using the injected XAI_API_KEY: chat/LLM features, image and video generation (Imagine), and voice (text-to-speech). Use when the app needs any "AI" / "assistant" / "chatbot" / "Grok" functionality, runtime image/video generation, or speech. Triggers on "AI", "LLM", "chatbot", "assistant", "Grok", "xAI", "generate text", "summarize", "generate image", "AI video", "voice", "text to speech", "TTS", "OpenAI" (use xAI instead).

Skills relacionados