DEV Community: weiyuan zhou

Create Viral AI Videos, Images, and Music with YVD

weiyuan zhou — Fri, 06 Nov 2026 20:53:24 +0000

YVD is an AI-powered platform that lets you generate videos, images, and music in seconds. Whether you need product demos, social media content, or creative assets, YVD provides powerful AI tools to bring your ideas to life.

Features

Text to Video: Turn your scripts and prompts into polished video clips
Text to Image: Generate high-quality images from text descriptions
AI Music: Create original music tracks for your projects
Image to Video: Animate your still images into dynamic videos
PNG Background Remover: Clean up product photos instantly

Why YVD

YVD is perfect for indie hackers, SaaS founders, and developers who need to create marketing content, product demos, and social proof without hiring a design team.

The freemium model means you can start with 20 free credits plus daily bonuses.

Try YVD at yvd.io

The platform supports everything from cinematic worlds and anime motion to product photography and fashion posters — all generated through simple text prompts.

One Workspace for AI Video, Image, and Music Generation

weiyuan zhou — Thu, 05 Nov 2026 09:35:05 +0000

Creative projects often start with a scattered toolchain: one service for images, another for video, and a third for music. Each tool brings its own credits, export formats, and interface. For solo creators and small teams, that context switching can cost more time than the generation itself.

I have been testing imov.dev, a unified creative AI platform that puts text-to-image, image-to-image, text-to-video, image-to-video, and AI music generation in the same workspace.

Why a single workspace helps

A shared workspace solves three practical problems:

Consistent credits. One credit balance covers every generation type, so you do not need to top up five different accounts.
Faster iteration. You can turn a still image into a clip, then add a generated soundtrack without exporting between tools.
Fewer handoffs. Assets stay in one place, which makes review and reuse much simpler.

A simple workflow

Generate or upload a reference image with text-to-image or image-to-image.
Animate it with image-to-video, or start fresh with text-to-video.
Create a music bed with the AI music generator.
Review everything in the workspace and export the final assets.

The same flow works for a quick social clip or a longer marketing video, and you can iterate on any step without rebuilding the project from scratch.

Pricing model

imov.dev uses pay-as-you-go credit packs instead of a monthly subscription:

Starter: 400 credits for $9
Standard: 2,500 credits for $49
Premium: 6,000 credits for $99

Credits are valid for one month, three months, and one year respectively, and the plans include commercial rights for marketing, social media, and client work. There is no recurring monthly commitment, which is useful if your generation volume changes from month to month.

When a unified tool makes sense

If your work regularly mixes images, short video, and background music, a single platform removes a lot of friction. You still need to review outputs carefully, write clear prompts, and keep a consistent visual direction, but the tooling stops getting in the way.

You can try the workflow at imov.dev.

Building a URL-First Submission Flow for an AI Tools Directory

weiyuan zhou — Sun, 01 Nov 2026 22:56:36 +0000

AI tool discovery is noisy. New products launch every day, and most "best AI tools" lists go stale within weeks. I built Offo (https://offo.dev) as a browsable directory that tries to keep the submission and browsing experience short.

Start with a URL, not a form

Most directories ask makers to fill in a long form before they see anything. Offo takes the opposite approach: paste a public website URL, and the directory drafts the listing from the site. The maker reviews the draft, adjusts the details, and publishes.

That flow only works if the input is a real, public product URL. Landing pages behind a login, staging URLs, and placeholder pages make the generated listing useless, so URL validation is the first gate.

Organize by task, not by hype

The catalog groups tools into categories such as Writing, Image, Video, Coding, Voice, Business, Marketing, Chatbots, Design, Productivity, Research, and Education. Each listing carries a short description, tags, and a direct link to the provider, so visitors can compare tools and leave for the product site without extra clicks.

Browse the full catalog at https://offo.dev/tools.

Keep the listing useful

A few rules that helped:

The listing should answer "what does this tool do?" in one or two sentences.
Tags matter more than long descriptions for discovery.
Every listing needs a working website link.
Featured and new-arrival sections should be curated, not purely chronological.

Pricing that does not block the first submission

Offo has a free plan with 3 submissions, a $5 one-time Basic plan with 30 submissions, and a $20 one-time Unlimited plan. Details are at https://offo.dev/pricing.

Try it

If you are building an AI tool, you can submit it at https://offo.dev/submit and see the generated listing before publishing. If you are looking for a tool, start at https://offo.dev and browse by category.

Good tools, better work.

One Workflow for AI Video, Images, and Music: Notes on imov.dev

weiyuan zhou — Sun, 01 Nov 2026 09:23:44 +0000

Most creative AI stacks end up as a pile of tabs: one tool for text-to-image, another for image-to-video, a third for music beds, and a billing dashboard per vendor. I have been looking at imov.dev as an experiment in collapsing that into a single workflow, and these are my notes.

What the platform actually covers

imov.dev bundles several generators behind one interface:

Text to image and image to image for stills and variations
Text to video and image to video for motion clips
AI music generation for background tracks and short cues

The entry point is a shared workspace, with separate studios for video, image, and audio, so switching medium does not mean switching accounts or re-uploading assets.

Pricing model

The thing that made me try it is the credit model rather than a subscription:

Pack	Credits	Validity
Starter	400	1 month
Standard	2,500	3 months
Premium	6,000	1 year

Credits are pay-as-you-go, with no recurring monthly commitment, and the listed price starts at $9 one-time. That fits bursty work: you buy capacity for a launch week, then stop paying instead of renting a seat you barely use.

Where this pattern helps

If you build content tooling, the interesting part is not any single model, but the shape of the API surface around them. A unified credit balance and one asset workspace removes a lot of glue code you would otherwise write to shuffle files between providers. Commercial usage rights are included for marketing, social, and client work, which is the question that usually blocks teams from adopting a generator in the first place.

Caveats worth testing

Credit validity differs per pack, so plan purchases against your production calendar.
Output quality per medium still depends on the underlying model, so benchmark against your own reference shots rather than demo galleries.
Check payment support for your region; cards, PayPal, Alipay, and WeChat Pay are listed.

If you want to poke at it, the studio is at imov.dev and the pricing detail is on the pricing page.

Designing an AI image + video workspace in the browser: credit costs, task history, and fewer tabs

weiyuan zhou — Sun, 25 Oct 2026 10:08:34 +0000

Most AI image tools are single-purpose: one page to generate, another to edit, another to make a video, and a fourth to upscale the result. When I started working on Uyo, the constraint I cared about was simpler than any model choice: keep the whole loop inside one browser workspace, and make the cost of each action obvious before the user clicks.

What the workspace actually does

Text to image - describe a scene and generate results.
Image to image - start from a reference photo instead of a prompt alone.
Upscaling and background removal - cleanup steps that used to mean opening a second tool.
Text to video and image to video - turn a prompt or a single still into motion.

It runs in the browser, so there is no installer and no platform checklist. The interface is available in English and Chinese.

Show the price before the request

The part I keep coming back to is credit visibility. Image and video generation share one balance, and the cost varies by model and output settings. That makes "generate" a small financial decision, not just a creative one, so the workspace displays an estimated credit cost before generation instead of after.

If you have ever queued a batch of 20 renders and only then noticed the balance, you know why this matters. It also removes a whole category of support questions.

Keep the output, not just the prompt

Every generation lands in My Creations, along with the task itself. In practice that means the history is the product: you come back to a result you made last week, not to a prompt you half remember. Keeping tasks and results together also makes the workspace usable on a laptop where you close the tab constantly.

Pricing, stated plainly

Uyo is a paid product. Credits are sold as one-time packs:

400 credits for $9, valid 30 days
2,500 credits for $49, valid 90 days
6,000 credits for $99, valid 365 days

Public tools, examples and guides can be browsed without an account. Generation requires an account and sufficient credits. I would rather write that in the first paragraph of a post than bury it behind a modal.

What I would change next

Three things are still rough:

Cost estimation for mixed workflows. A single image is easy to estimate; an upscale plus a background removal plus a video pass is not. Showing a running total per project would help.
Better reference management. Right now a reference photo is per task. A small library of recurring references would save retyping URLs.
More explicit model notes. Different models behave differently on the same prompt, and the UI should say so rather than implying one universal result.

None of these are exotic. They are the kind of thing you only notice after using your own tool for a few weeks, which is exactly why shipping early mattered.

Try it

If you want to see the workspace, it is at uyo.io. If you build something similar, I would be interested in how you handle credit estimation in the UI - that seems to be the part every tool gets slightly wrong.

Disclosure: I work on Uyo.

Build a Branded App Preview for Your Creator Business in Minutes

weiyuan zhou — Mon, 14 Sep 2026 08:48:52 +0000

Creating a branded app preview used to mean hiring a designer or wrestling with design tools. That changed when I started using appyq to describe an offer and instantly get a free preview with home, content, and pay screens.

Why an app preview matters

For creators across eight business types, a polished preview helps you validate an idea before writing a line of code. Instead of guessing what your app should look like, you describe your offer and see a ready-made layout.

How it works

Describe your offer in plain language.
Generate a free branded preview.
Review the home, content, and pay screens.

You can try it out at https://appyq.com and iterate on your pitch in a few clicks.

Final thoughts

Previews lower the barrier between an idea and something you can show. If you sell content, courses, or commerce, it is worth a look.

Meet AppyQ: Free Branded App Previews in Seconds

weiyuan zhou — Mon, 07 Sep 2026 04:04:14 +0000

I just shipped a small product called AppyQ and wanted to share what I learned building it.

What it does

AppyQ is an AI app-preview generator. You describe your offer in plain language, and it produces a branded app preview in seconds — including a home screen, a content screen, and a pay screen.

It targets eight creator business types: subscription, one-time purchase, membership, pre-order, and others. The idea is to let a creator validate a product idea and a business model before writing any code.

Why I built it

The biggest friction for me when starting a product was the gap between "I have an idea" and "I have something I can show to people." I usually had to:

hand-draw screens in Figma,
fake a checkout flow,
write a one-page spec that nobody wanted to read.

AppyQ compresses all of that into a single prompt. It is not a full app builder — it is a preview tool. The output is good enough to test a hypothesis, show an investor, or hand to a designer.

What it is not

It is not a no-code app builder that ships real apps.
It is not a wireframe tool.
It is not a design system.

It is a fast way to get a branded, shareable preview out of a paragraph of text.

Try it

The first preview is free: https://appyq.com/

Feedback is welcome — I would rather know what is missing now than six months from now.

Disclosure: I used AI assistance to draft this post, and the product information and claims are mine.

How appyq.com Turns an Offer Into a Branded App Preview

weiyuan zhou — Thu, 27 Aug 2026 04:39:13 +0000

appyq.com is a web app for creators who want to visualize an offer before launch.

Describe your offer and generate a free branded app preview with home, content, and pay screens for eight creator business types. The preview helps teams think through the product experience before building or launching.

Learn more: https://appyq.com

Appyq: Describe your offer, get a free branded app preview for your creator business

weiyuan zhou — Tue, 18 Aug 2026 08:28:56 +0000

If you sell a cohort course, a coaching program, or any kind of paid community, you have probably wondered what your offer would look like as a real mobile app — without hiring an agency first.

I built Appyq to answer exactly that question.

What it does

You describe your offer in plain language, and Appyq generates a free branded app preview for it — complete with home, content, and pay screens. It comes with templates for eight common creator business types, so you can see your own course or coaching program rendered as an app in minutes instead of weeks.

Why it is useful

Validate before you build: show prospects and stakeholders a concrete preview instead of a slide deck.
Free to try: the preview generation costs nothing — no credit card required.
Made for course creators: the roadmap focuses on course delivery for paid cohorts and coaching programs, with controlled access, drip lessons, learner progress, and follow-up signals.

Try it

The tool is live at appyq.com. Type in your offer description, pick a business type, and you get a branded preview you can share.

Feedback is very welcome — especially from anyone running paid cohorts or coaching programs. What would you want an app preview to show first?

Build a Deterministic AI Video Brief Generator with Vanilla JavaScript

weiyuan zhou — Sat, 01 Aug 2026 04:29:29 +0000

Generative video models are improving quickly, but a surprisingly ordinary problem still wastes a lot of time: the input brief changes every time someone rewrites it.

One prompt includes the lens and lighting. The next forgets the aspect ratio. A later revision changes the hero product from ceramic to glass. The model may be capable, but the production input is unstable.

For repeatable work, it helps to separate two jobs:

deciding what the creative direction should be;
translating that decision into a prompt and storyboard.

The first job is creative. The second can be deterministic.

In this tutorial, we will build a small browser app that turns a structured form into:

a master image or video prompt;
continuity constraints;
a three-to-six-shot storyboard;
downloadable JSON for the rest of a production workflow.

It uses no framework, no build step, and no AI API.

Model the brief as data

Start with the information that should remain stable throughout a generation session:

const brief = {
  projectType: "video",
  subject: "a matte ceramic skincare bottle on a mirrored plinth",
  style: "premium editorial product film, tactile, photorealistic",
  camera: "slow macro push-in with a 50 mm lens",
  lighting: "soft cobalt edge light with a warm amber key",
  requirements: "readable label and consistent bottle geometry",
  negative: "warped typography, duplicated objects, flicker",
  aspectRatio: "9:16",
  shotCount: "4",
  duration: "12 seconds"
};

This object does more than organize form values. It gives every downstream function the same source of truth.

Normalize input before composing a prompt

Form input often contains accidental line breaks and repeated spaces. A tiny normalizer keeps the output readable:

const clean = (value) =>
  String(value || "")
    .trim()
    .replace(/\s+/g, " ");

Next, convert optional fields into labeled sentences:

const sentence = (label, value) => {
  const normalized = clean(value);
  return normalized ? `${label}: ${normalized}.` : "";
};

Now the prompt builder can be explicit without being repetitive:

function buildPrompt(input) {
  const subject = clean(input.subject);
  if (!subject) {
    throw new Error("A core idea is required.");
  }

  const parts = [
    `Create a cinematic AI video featuring ${subject}.`,
    sentence("Visual direction", input.style),
    sentence("Camera and composition", input.camera),
    sentence("Lighting and color", input.lighting),
    sentence("Required details", input.requirements),
    sentence("Avoid", input.negative),
    sentence("Delivery format", `${clean(input.aspectRatio)} aspect ratio`)
  ];

  return parts.filter(Boolean).join(" ");
}

The result is deterministic: identical input produces identical output. That is useful when comparing models or regenerating a shot because the brief is no longer another moving variable.

Treat continuity as a first-class object

A storyboard is more useful when global constraints are stored separately from individual shots.

function buildStoryboard(input) {
  const requestedCount = Number.parseInt(input.shotCount, 10);
  const shotCount = Math.min(
    6,
    Math.max(3, Number.isFinite(requestedCount) ? requestedCount : 4)
  );

  const beats = [
    "Establish the subject and environment",
    "Move closer to reveal the defining details",
    "Introduce a clear transformation or action",
    "Show the strongest hero composition",
    "Add a contrasting angle or supporting detail",
    "Resolve on a clean final frame"
  ];

  return {
    aspectRatio: clean(input.aspectRatio) || "16:9",
    totalDuration: clean(input.duration) || "12 seconds",
    continuity: {
      subject: clean(input.subject),
      visualStyle: clean(input.style),
      lighting: clean(input.lighting),
      requirements: clean(input.requirements),
      negativeConstraints: clean(input.negative)
    },
    shots: beats.slice(0, shotCount).map((purpose, index) => ({
      shot: index + 1,
      purpose,
      visual: `${clean(input.subject)}; maintain the ${clean(input.style)} direction`,
      camera: clean(input.camera),
      transition:
        index === shotCount - 1
          ? "hold on final frame"
          : "clean motivated cut"
    }))
  };
}

There are two deliberate limits here:

at least three shots, so the output has a beginning, development, and resolution;
at most six shots, so a simple concept does not turn into an unmanageable production.

Those numbers are not universal. The important part is making the rule visible and testable.

Export JSON in the browser

The browser can generate a downloadable file without a server:

function downloadStoryboard(storyboard) {
  const blob = new Blob([JSON.stringify(storyboard, null, 2)], {
    type: "application/json"
  });
  const url = URL.createObjectURL(blob);
  const link = document.createElement("a");

  link.href = url;
  link.download = "creative-storyboard.json";
  link.click();

  URL.revokeObjectURL(url);
}

That JSON can be stored with a project, reviewed in a pull request, or transformed for another tool later.

Add small tests where inconsistency hurts

The prompt does not need snapshot tests for every word. Test the rules that matter:

import assert from "node:assert/strict";
import test from "node:test";

test("shot count is clamped to six", () => {
  const storyboard = buildStoryboard({
    subject: "a glass bottle",
    shotCount: "12"
  });

  assert.equal(storyboard.shots.length, 6);
});

test("a subject is required", () => {
  assert.throws(
    () => buildPrompt({ projectType: "image" }),
    /core idea is required/i
  );
});

The built-in Node test runner is enough for a project this size.

Where generation tools fit

This starter does not replace an image or video model. It prepares a stable instruction set for one.

A practical workflow looks like this:

agree on the brief in the local app;
save the JSON with the project;
use the master prompt for the first generation;
generate individual shots while preserving the continuity object;
change one variable at a time when comparing results.

For an integrated generation workspace, the finished brief can be used with the Vynyo AI Video Generator.

Repository

The complete dependency-free starter, tests, and Replit configuration are available in the public Vynyo Creative Brief Starter repository.

The larger lesson is simple: better generations do not always begin with a more complicated prompt. They often begin with a smaller set of decisions that stays consistent.