Track · Generative media
Build with image and video models in a week.
Not a tour of art apps. A developer's week: you will treat image and video models as APIs and pipelines you build with, wire them into code, and ship a small reproducible media tool plus a set of assets you actually use. By Sunday you will have generated images and video programmatically, built a pipeline an agent can run, and put the output into a real project. Plan on roughly ten to twelve focused hours a day.
Why this belongs in an AI-native foundation
This track earns its place by being about engineering, not aesthetics: calling models from code, building pipelines you can version and rerun, evaluating output with judgment, and integrating media into the software you ship. That is the same direct-inspect-verify loop as the rest of agentic engineering, applied to a new kind of model. If you just want pretty pictures, a consumer app is faster. If you want to build with generative media, start here.
The mental model: three layers
Generative media is a stack, not a button. The model layer (FLUX, Stable Diffusion, Veo, Kling, Wan) does the generation. The workflow layer (ComfyUI node graphs, the diffusers library, a hosted API like fal.ai or Replicate) orchestrates it. The integration layer is your software: a game's textures, a site's images, an app's media feature. You will work all three this week, and the agent will write most of the code in the middle and top.
#Day 0: pick your path and set up
There are two on-ramps. Most people should do a bit of both; choose your primary by your hardware and goal.
- Hosted (any machine): a multi-model API. fal.ai and Replicate both give one API key and access to hundreds of image and video models. Best if you lack a strong GPU or want to ship fast.
- Local (good GPU, or Apple Silicon with enough memory): ComfyUI for node-based control, plus Hugging Face diffusers for the code path. Best for control, privacy, reproducibility, and zero per-image cost.
ask your AISet up a Python project (uv) for a generative-media pipeline, with an AGENTS.md documenting conventions: keep model calls behind a small interface so we can swap providers, store API keys in environment variables (never in code), log every generation's prompt and seed, and propose a plan before large changes. Then write a smoke test that generates one image from a text prompt through the provider I chose.
Concept · Models are services with tradeoffsBefore generating anything, you are making engineering decisions: local vs hosted (cost, privacy, reproducibility vs convenience), secrets handling (keys in env, never committed), and a provider interface so you are not locked to one model. The field moves monthly and licenses differ per model, so build to swap, and check commercial terms before you ship anything.
Your turn: generate the same prompt on two different models and put the results side by side. Learning to see the difference between models is the first real skill here.
▶
Running A project that generates one image from code, with keys in env and a written harness.
1Day 1: first generations and the prompt as a spec
ask your AIBuild a small script that takes a structured prompt (subject, composition, lighting, style, and a negative prompt) plus a seed, and generates an image, saving the image alongside a JSON record of every parameter used. Generate a set of ten variations of one concept by changing only the seed, then ten more by changing only the style field.
Concept · Diffusion, seeds, and prompt structureMost image models are diffusion models: they start from random noise and denoise it into an image over several steps. The seed is the starting noise, so the same prompt and seed reproduce the same image, which is how you get reproducibility. A good prompt is a structured spec, not a sentence: subject, composition, lighting, lens, style, and what to avoid. This is the spec-then-iterate loop from the rest of the path.
Your turn: fix the seed and change one word at a time to see exactly what each part of the prompt controls. Then save a seed you like, you will reuse it for consistency later.
▶
Working Reproducible image generation from a structured spec, with every parameter recorded.
2Day 2: control and consistency
ask your AISet up a ComfyUI workflow (or a diffusers pipeline) that uses ControlNet so I can guide a generation with a pose or a depth or edge map, plus image-to-image so I can start from a rough sketch. Then show me how to apply a LoRA to lock a consistent style across many images. Save the workflow as a file I can version and rerun.
Concept · ControlNet, LoRA, and workflows as codeRaw prompting only gets you so far; real production uses control. ControlNet conditions a generation on a pose, depth, or edge map so composition is intentional. Image-to-image starts from an existing picture. A LoRA is a small fine-tune that locks a style or character for consistency. The big idea: a ComfyUI graph is a program you can save, diff, and share, the same reproducibility discipline as your code.
Your turn: generate the same character in three poses using ControlNet plus a style LoRA. Consistency across images is the hard problem generative media is still solving, and you are now doing it on purpose.
▶
Working Controlled, consistent generations from a versioned workflow, not one-off prompt luck.
3Day 3: pipelines in code
ask your AITurn the workflow into a real pipeline: a script that reads a spec file describing a whole asset set (say, a tileable stone texture, a wood texture, a metal texture, and a skybox), generates each with the right settings, post-processes them (resize, make seamless where needed), and writes them into an output folder with a manifest. Make it batchable and resumable.
Concept · Generation as an automated pipelineThis is the heart of the track: moving from clicking to a pipeline the agent writes and you direct. You will meet batch generation, parameter sweeps, post-processing, and a manifest so every output is traceable to its inputs. Whether you call diffusers locally or a hosted API, the asset set becomes reproducible from a spec file, which is exactly how production media pipelines work.
Your turn: change one line in the spec file and regenerate the whole set. A pipeline you can rerun from a spec is the difference between a hobby and an engineering workflow.
▶
Working A spec-driven pipeline that generates a complete, reproducible asset set in one command.
4Day 4: video
ask your AIAdd video to the pipeline. Generate short clips with a current model through a hosted API, and crucially use image-to-video starting from images I made earlier so the look stays consistent. Handle it like the slow, asynchronous job it is: submit, poll for completion, download, and retry on failure. Let me compare a couple of models on the same input.
Concept · The video landscape and async jobsVideo is where the field moves fastest. Treat specific model names as current options to verify, not permanent infrastructure: Google Veo, Runway, Luma, Kling, Seedance, and open-weights Wan-style models all evolve quickly and may be reachable directly or through hosted hubs such as fal.ai and Replicate. Image-to-video anchors the result to a frame you control. Because generation is slow, you will write real asynchronous job handling, a genuine engineering skill. Build behind a provider interface so model churn becomes configuration, not a rewrite. OpenAI's Sora discontinuation is the cautionary example.
Your turn: take one of your Day 1 images and animate it with image-to-video. Watching a still you generated start to move is the moment this clicks.
▶
Working Generated video clips, anchored to your own images, with proper submit-poll-download handling.
5Day 5: into a real project
ask your AIWire the pipeline into something real. Either feed the textures and skybox into the arena from the FPS track, or auto-generate hero images and per-page social-card images for a site from the web track. Make it a repeatable step: a command that regenerates the project's media assets from the spec, ready to commit.
Concept · Media as part of the buildGenerated media only matters when it ships inside software. You will connect your pipeline to a real target: game assets for the FPS track, or imagery and automated Open Graph cards for the web track. Auto-generating an OG image per page is a small, genuinely useful build step that most sites do by hand. This is the integration layer, where generative media becomes an asset pipeline.
Your turn: regenerate one project's assets entirely from the spec and diff the result in Git. Treating media as build output, not hand-made one-offs, is the professional move.
▶
Working Your generated media is powering a real game or site, regenerable on demand.
6Day 6: build a small media tool
ask your AIWrap the pipeline in a tiny web app: a prompt box and controls, a generate button that runs the pipeline through my provider interface, a gallery of results with the seed and settings shown under each, and a simple history. Keep API keys server-side, add basic cost guards, and let me favorite the good ones.
Concept · Wrapping a model in a productNow you build the thing most people pay for: a product around a model. This bridges to the Apps track and surfaces real concerns, keeping keys server-side, adding cost controls, and building an evaluation UI so judging output is part of the tool. Showing the seed and settings under each image makes your own work reproducible, which is the habit that separates a tool from a toy.
Your turn: add a side-by-side compare view for two models on the same prompt. Building the evaluation surface trains your taste, one of the five chops.
▶
Working Your own minimal media studio: prompt in, reproducible results out, with history and cost guards.
7Day 7: ship, evaluate, and the taste pass
ask your AIHelp me deploy the tool so I can use it from anywhere, document how to reproduce any result (seed, model version, workflow file), and do an evaluation pass: curate the best outputs, compare models on my real prompts, and write down what each is good at. Help me put together a small showcase of what I built and generated this week.
Concept · Shipping, evaluation, and reproducibilityFinishing means deploying the tool, documenting reproducibility (anyone should be able to regenerate a result from its record), and doing a real evaluation, judging models against your actual needs instead of demo reels. Evaluation and taste are chops no model has for you. A curated showcase of a working tool plus the media it makes is something you can genuinely show off.
Know the rules before you ship
Commercial rights, training-data and IP questions, and disclosure norms vary by model and by use, so check each model's license before using output commercially, prefer permissively licensed models when that matters, and consider content-provenance standards (Content Credentials / C2PA) and honest disclosure. Being the person who understands the licensing is part of being the senior partner.
Stretch goals (each its own adventure)
- Train your own LoRA — fine-tune a consistent style or character of your own on top of an open model.
- An evaluating agent — have an agent score generations against your spec and auto-pick the best.
- A fully automated pipeline — spec in, finished media committed to a project, no clicks.
▶
Shipped A deployed media tool, a reproducible pipeline, and a set of assets in a real project, built in a hard week.
#Where to learn more
The durable, excellent 2026 references (specific video tutorials age fast, so favor official docs and the official channels, then search for current-year walkthroughs):
- Workflows & control: ComfyUI and its docs and example workflows, the most important tool for serious local control.
- Code-first generation: Hugging Face diffusers and the free Hugging Face courses (including the diffusion course) for the fundamentals of how these models work.
- Multi-model APIs: fal.ai and Replicate docs, the fastest way to call image and video models from code.
- Models & weights: Black Forest Labs (FLUX), Stability AI (Stable Diffusion), and Hugging Face for open weights and model cards.
- Video: Google AI Studio (Veo), Runway, and Luma, with Kling, Seedance, and open-weights Wan reachable through the multi-model hubs above.
- The chops: bring it back to Vibe → agentic, because spec, evaluation, and taste are exactly what generative media rewards.
The honest part
This moves faster than any other track: model names will change within months. That is why the durable skills are the point, building swappable pipelines, calling models from code, evaluating with judgment, and integrating media into real software. Learn the stack, not just this month's model, and you will keep up no matter what ships next. Get excited, then put in the hours.
Built to be rebuilt. Open source, no tracking, works offline.