2026년 8월 22일 토요일

Why Solid-State Batteries Short-Circuit: The 20-Year Lithium Dendrite Mystery, Solved

 "Solid-state batteries will fix everything about EVs." You've heard it for years: no fires, faster charging, longer range. And yet mass production keeps slipping. One of the reasons is almost absurd when you say it out loud: the softest metal in the battery punches through the hardest ceramic in it, and shorts the cell.

Lithium metal cuts like cold butter. Garnet ceramic electrolyte turns a knife edge. Butter is drilling through porcelain. It shouldn't work — and it happens in cell after cell.

For more than two decades, the field split into two camps over why. In April 2026, a Max Planck team published a paper in Nature that settles the argument. This post is about what they found, why it took so long, and what it changes for the battery in your next car.

A tree-like lithium dendrite grows from the lithium anode (left), splitting the ceramic electrolyte (center) on its way to the cathode (right). Contact means a short circuit.

Solid-state batteries in one minute

The lithium-ion cells in your phone and car use a liquid electrolyte — lithium ions swim through it between the anode and cathode. The problem is that this liquid is a flammable organic solvent. Most EV fire headlines start there.

A solid-state battery replaces the liquid with a solid, usually a ceramic. Ceramic doesn't burn. Better still, it lets you use pure lithium metal as the anode instead of graphite, which packs far more energy into the same volume. Non-flammable and higher capacity: on paper, it's the perfect cell.

Then you cycle it. After repeated charging, tree-like lithium crystals — dendrites — start growing from the anode surface. When a dendrite crosses the ceramic and touches the cathode, the cell shorts and dies.

The 20-year argument: electrons or force?

How does soft lithium get through hard ceramic? Two hypotheses competed.

Hypothesis A — the electrochemical camp: "the ceramic leaks."
Ceramic is made of tiny crystal grains, and the boundaries between grains can leak a trickle of electrons. Wherever electrons leak, lithium ions meet them and plate out as metal inside the ceramic. These isolated deposits link up and form a path through. The analogy: there are hairline channels in a wall, mold grows inside the wall first, then connects and breaks through.

Hypothesis B — the mechanical camp: "lithium pushes the ceramic apart."
Every ceramic has microscopic pre-existing cracks from manufacturing. During charging, lithium is forced into these cracks. Trapped with nowhere to go, it builds internal pressure that pries the crack tip open and splits the ceramic. The analogy: water seeping into a rock crevice, freezing, and splitting the rock.

Both are plausible, which is why the debate lasted two decades. And the two camps prescribe opposite fixes: if A is right, you need to block electron conduction in the ceramic; if B is right, you need a tougher ceramic. Not knowing which, research funding flowed in both directions.

The decisive evidence: nothing ahead of the tip

What Dr. Yuwei Zhang's group at the Max Planck Institute for Sustainable Materials did sounds simple: they looked directly at where a dendrite had passed through, at atomic resolution.

Simple to say, brutal to do. Lithium degrades the instant it meets oxygen or moisture, and an electron microscope's beam damages it too. Sample preparation and imaging had to stay under vacuum and cryogenic temperatures without a single break.

The key result:

No lithium enrichment was detected in the ceramic ahead of the dendrite tip.

If Hypothesis A were right, lithium should already be plated inside the ceramic ahead of the advancing dendrite — the mold should be there before the breakthrough. It wasn't. The region ahead of the tip was clean. What the team did find was stress signatures in the ceramic around the crack and plastic deformation inside the lithium — the fingerprints of metal being forced in under enormous pressure.

Electron backscatter diffraction and phase-field simulations pointed the same way. After twenty years, the mechanical camp won.

The mechanism: a waterjet

The authors offered an analogy I can't improve on:

"The soft lithium metal is able to penetrate the stiff ceramic electrolyte, like a continuous waterjet that penetrates a rock."

Left: water is soft, but forced through a narrow nozzle at high pressure it cuts stone. Right: lithium is soft, but confined in a micro-crack it builds pressure that pries the crack tip open. Strength isn't doing the work — pressure is.

Think of an industrial waterjet cutter. Water is about as soft as matter gets. Fired through a fine nozzle at thousands of atmospheres, it slices steel and granite. The water didn't get harder. The pressure got concentrated.

Lithium does the same thing. During charging, lithium ions plate out as metal at the anode. When that happens inside one of the ceramic's micro-cracks, the new metal has no exit. It keeps accumulating. Even a soft material, confined on all sides while its volume grows, develops rapidly rising hydrostatic pressure. That pressure loads the crack tip in tension — and brittle materials like ceramic are weak in tension. Crack. Lithium flows into the new gap, pressure rebuilds, crack again. Repeat until the dendrite reaches the far electrode.

Hypothesis A (electrochemical)Hypothesis B (mechanical) — winner
CauseElectrons leaking along grain boundariesHydrostatic pressure of lithium in cracks
Ahead of the dendrite tipLithium should already be platedShould be clean
ObservedNo plating ✗Clean + stress signatures ✓
Everyday analogyMold growing inside a wallWaterjet cutting rock
PrescriptionBlock electron conductionTougher ceramic / manage flaws

An arXiv model paper says the same thing with equations

Around the same time, an analytical model of exactly this process appeared on arXiv (2603.20113). Its core idea is an energy trade-off. Growing a dendrite costs mechanical energy to crack the ceramic. Not growing it costs electrical energy, because current has to detour around the obstruction. Nature takes the cheaper path, so the dendrite advances the moment cracking costs less than detouring.

One conclusion from the model is practically important: the critical current density for dendrite growth scales inversely with the largest flaw length to the 3/2 power. In plain terms, the single biggest defect in the ceramic decides the fate of the cell. Not the average — the worst case. If you work in semiconductors this sounds familiar: a wafer can be pristine everywhere except the one particle that kills the die. It also explains why nominally identical cells fail so inconsistently, and predicts that the scatter follows a Weibull distribution, just like ceramic tensile strength.

So when does my EV get one?

Settling the mechanism doesn't ship a battery tomorrow. What it does is tell everyone where to spend the money. The Nature team lays out three paths:

  1. Tougher ceramics (higher fracture toughness) — so pressure builds without the crack opening. In waterjet terms: swap the rock for harder rock.
  2. Deliberate micro-voids to redirect cracks — engineered empty space inside the ceramic gives dendrites and cracks somewhere to go that isn't straight across to the other electrode. Think of a flood spillway.
  3. Protective coatings on the lithium electrode — stop dendrites at the point where they start.

And the arXiv model adds a fourth: process control aimed at the largest flaw, not the average. Design the manufacturing line to kill the worst defect, not to improve the mean.

Either way, "stop the electron leakage" just dropped down the priority list. Funding that spent twenty years split between two camps can now concentrate on one. That alone changes the pace.

What stayed with me

What struck me most about this paper wasn't the conclusion — it was the method.

Two hypotheses coexisted for twenty years for one reason: nobody could look directly at a dendrite tip. Lithium dies in air and dies under an electron beam, so everyone reasoned from indirect evidence. The Max Planck team didn't invent a new theory. They perfected the tedious sample-handling technique that keeps vacuum and cryogenic conditions unbroken from start to finish. Then they looked. The answer was sitting there.

I work in the semiconductor industry, and I see this pattern constantly: process and equipment teams arguing for months over a defect's root cause, until someone finally cross-sections the part and puts it under a microscope, and it's over in ten minutes. Far more problems go unsolved for lack of a way to see than for lack of theory.

References

  • Yuwei Zhang et al., "Mechanically driven Li dendrite penetration in garnet solid electrolyte," Nature (2026). DOI: 10.1038/s41586-026-10415-9
  • Ansgar Lowack, "An Analytical Model of Critical and Subcritical Alkali Metal Dendrite Growth in Ceramic Solid Electrolytes," arXiv:2603.20113 (2026)

This post explains published research for a general audience; see the papers for precise figures and conditions. Part of an ongoing series on solid-state physics in everyday life. The Korean version is on my Naver blog.

2026년 8월 21일 금요일

Higgsfield Pricing Explained: Monthly vs Annual, What "Unlimited" Really Means, and the MCP Credit Trap

 Sooner or later, anyone making AI video seriously ends up staring at the Higgsfield checkout page. Having Seedance, Veo, Kling, and a dozen other models behind one login is genuinely appealing. But the pricing page raises more questions than it answers: monthly or annual? Is "Unlimited" actually unlimited? Is this limited-time deal worth it?

I've paid for it, used it through the web and through MCP, and burned credits in ways I didn't expect. This is the breakdown I wish I'd had before subscribing — with special attention to the fine print on "Unlimited" and the one rule that catches almost everyone who connects Higgsfield to an AI agent: Unlimited does not apply to MCP.

Base plans: monthly vs annual billing

Monthly and annual prices differ on most tiers. Annual means you pay a full year upfront — not twelve smaller monthly charges.

PlanMonthly billingAnnual (per month)SavingsCredits / month
Starter$15$150%~200
Plus$49$39~20%~1,000
Ultra$129$99~23%~3,000 (up to 9,000 on larger packages)
Business$89 / seat$62 / seat~30%1,500 / seat (2–15 seats, shared pool)

Three things worth noticing:

Starter has no annual discount. It's $15 either way, so there's no reason to lock yourself into a year. Go monthly and cancel when you're done.

Starter blocks the top models. Only a selected set of models is available, and flagship models like Veo aren't among them. "I'll start cheap and try Veo" doesn't work on this tier.

Plus is the real starting line. Every model unlocks at Plus ($49 monthly / $39 annual), and the Unlimited features discussed below only begin at Plus.

A simple decision rule:

  • One- or two-month project: Plus, monthly ($49).
  • Ongoing work, 6+ months: Plus, annual. The breakeven is roughly month 10 ($468/year vs $49/month), but the practical crossover — factoring in that you'll likely keep it — is around six months.
  • Just curious: Starter, monthly ($15), knowing the good models are off-limits.

What "Unlimited" actually means

Plus and above include models marked "Unlimited." Don't take the word at face value. Higgsfield's own documentation states that eligible unlimited access can be model-, surface-, time-, queue-, and fair-use-specific. In plain terms:

1. Most unlimited models are image models. Of the eight models listed as unlimited, six generate images, not video (Seedream, Flux.2 Pro, Nano Banana, GPT Image, and so on). If you subscribe expecting unlimited video, you'll be disappointed.

2. The unlimited window varies by model.

  • Most included models: 365 days of access
  • Newest flagship models: much shorter windows, e.g. 7 days
  • Some models: a free generation pool instead of true unlimited
  • Cancel the subscription and unlimited access goes with it

3. Unlimited runs in the slow queue. Unlimited generations use the standard shared queue, which slows down during peak traffic. Credit-based generation uses a priority queue at full speed. Same model, different speed depending on how you're paying.

4. Automation is prohibited. Scripting, automation tools, credential sharing, and reselling access all violate fair use. Unusual activity can get generations throttled or access paused.

Limited-time deals: what to check before buying

Separately from plan-included unlimited, Higgsfield sells time-boxed unlimited add-ons around model launches. Recent examples:

  • 30-Day Seedance Unlimited: Enhanced Seedance 2.0 Fast with no credit deductions for 30 days
  • 14-day programs with 7 days unlimited: shorter launch-week offers on new flagship models

They can be good value, but read the conditions:

Resolution caps. The 30-day Seedance deal covered 480p and 720p only. 1080p output required switching to credit mode. A sensible workflow: draft unlimited, then re-render only the final picks at 1080p on credits.

Sale close date and access end date are different. One offer closed sales on July 12 with access ending July 17. Buy on the last day and you don't get your full 30 days. Do the math before checkout.

One job at a time. Unlimited processes a single concurrent generation. You can't queue a batch overnight the way you can with credit mode, so "unlimited" is slower in practice than it sounds.

The rule that matters most: Unlimited does not apply to MCP

If you remember one thing from this post, make it this one.

Connecting Higgsfield to Claude or ChatGPT via MCP is convenient — you generate images and video directly in the conversation. I use it this way myself. But Higgsfield's policy is explicit:

Unlimited only removes cost when generating directly on higgsfield.ai. Any generation made outside it, including through MCP, CLI, Canvas, Supercomputer, and other automated tools, always deducts credits, regardless of your Unlimited status.

That covers every kind of unlimited:

  • 365-day plan-included unlimited → not honored over MCP
  • Marketplace unlimited bundles → not honored over MCP
  • Time-limited promos like 30-Day Seedance → not honored over MCP

If you bought unlimited, generated happily through Claude, and watched your credit balance drain anyway — this is why.

Practical implications:

  • To use unlimited, generate on the higgsfield.ai website directly.
  • To work through MCP, accept that credits will be deducted. Push bulk, non-urgent work to the web.
  • Split the workflow: idea testing and volume generation on the web under unlimited; only what the agent workflow genuinely needs through MCP.

The exception: "Unlimited MCP" is a separate product

Confusingly, Higgsfield recently launched something called Higgsfield Unlimited MCP — the first time unlimited generation works inside Claude and ChatGPT rather than only on the web. It's distinct from everything above, and the conditions matter:

  • Offered as a 24-hour free trial for new users, with a limited availability window
  • Requires card details; auto-converts to a Plus monthly plan unless cancelled
  • Cancelling doesn't cut the trial short — you keep the full 24 hours
  • Covers 11 image models (up to 2K), 5 audio models, and 7 video models (1080p, 7–8 second clips)
  • Audio works on the web and in Claude, but not in ChatGPT
  • Generations run one at a time, no parallelism — that's part of how the trial stays free

Worth trying if you want to see how much you can produce in a day. Set a calendar reminder to cancel before the auto-conversion kicks in.

Summary

  1. Starter has no annual discount — go monthly. From Plus up, annual pays off if you'll use it 6+ months.
  2. "Unlimited" comes with model, duration, resolution, and queue conditions attached.
  3. For limited-time deals, check both the sale close date and the access end date.
  4. Unlimited applies only on the Higgsfield website. MCP and CLI always deduct credits.
  5. Unlimited MCP is a separate trial product — watch the auto-conversion.

The word "unlimited" is exciting. Before you click pay, get into the habit of asking: unlimited where, on which modelsuntil when, and how many at once. That habit is what keeps your credits alive.

Pricing, credit policies, and promotional terms for AI services change frequently. Figures here reflect August 2026 and should be verified on Higgsfield's official pricing page before purchase. The Korean version of this post is on my Naver blog.

2026년 8월 20일 목요일

Claude Code vs Codex vs Gemini vs Grok: Which AI Assistant for Which Task

 The list of AI assistants worth knowing has gotten long. A while back, using ChatGPT well was enough to feel ahead of the curve. Now there's Claude, Claude Code, Codex, Gemini, and Grok, and the names and feature sets blur together fast. I use these for technical and engineering work — process data, analysis scripts, reading papers and reports, staying current on fast-moving tech — so I ran the same kind of tasks through all four and compared where each one actually earns its keep. Note: this is about Claude Code, the coding-and-project agent, not the general chat version of Claude.

The short version

  • Claude Code — best at reading and explaining existing code
  • Codex — best at running project-scale coding work and automation
  • Gemini — best at digesting and comparing large volumes of documents at once
  • Grok — best at surfacing what's happening right now

None of them is universally "the best" — the task determines the right tool.

1. Claude Code — reads your codebase like a colleague who's actually paying attention

Claude Code doesn't work like pasting a snippet into a chat box. It looks across a project's files, figures out how they connect, and works from that picture. For a data-analysis project, you might ask:

First check this project's file structure. Explain what each file does, and trace how data flows in and gets turned into the output charts. Don't modify anything yet — just analyze.

That's genuinely useful on old code you wrote yourself and no longer fully remember — vague variable names, no comments, no memory of why a given approach was used. Claude Code is good at reconstructing that story.

Strengths: understanding existing code structure, planning before it touches anything, working across multiple files, explaining errors, summarizing what changed after an edit.
Weaknesses: sometimes needs execution/environment setup; without a clearly scoped task it can touch more than intended; correctness of any technical calculation still needs independent verification.

2. Codex — feels like handing off actual project work

Codex also writes and edits code, but it's better suited to handling several linked tasks as one project rather than one-off snippets:

Read this CSV, check for missing values and outliers, compute mean and standard deviation for each variable, save the results as a table and a chart, and document how to run it in a README. Show me your plan before you start.

OpenAI describes Codex as a coding agent for writing, reviewing, and shipping project-level work — feature development, fixes, and refactors in one pass. In technical/engineering work, that maps to: cleaning up result files, repetitive data transforms, auto-generating charts, comparing results across conditions, refactoring analysis scripts, small internal tools, and figure-generation pipelines. If you're re-running the same analysis on new data every week, this is where the time savings compound.

Strengths: handles project-scale work well, good for automating repeated tasks, chains writing/editing/running/reviewing together, easy to check step by step.
Weaknesses: needs a specific brief up front; handing it something too large at once makes results hard to verify; you still need to confirm the output actually serves your purpose.

Rough distinction: Claude Code is better for understanding code that already exists; Codex is better for pushing a multi-step task through to completion. Results vary by environment and model version, of course.

3. Gemini — the one for wading through a stack of documents

Gemini's advantage shows up once you're comparing several long documents, not just reading one. Google notes that Gemini's long-context capability can process large amounts of text, code, images, and video at once, with some models supporting over a million tokens of input. One report barely tests that; five related ones do:

Compare these 5 papers. Put the following into a table: 1. research goal 2. method 3. materials used 4. key results 5. limitations 6. where conclusions diverge 7. what still needs further study

Reports on similar topics differ in test conditions, samples, and measurement methods in ways that take a while to spot by hand; Gemini gets you a first-pass comparison table fast.

Strengths: comparing multiple documents, parsing long reports, producing tables/summaries, integrates with Drive/document workflows, can also pull in recent sources.
Weaknesses: feeding in more documents doesn't guarantee more accuracy; it can blend conditions from different sources; there's a real risk of reading only the summary and never the source. Always re-check numbers and conditions against the original after Gemini summarizes it — one sentence in a report can flip the conclusion.

4. Grok — fastest read on what's happening right now

Grok's edge is live search. According to xAI's documentation, Grok can pull current information via web and X search and browse pages while forming an answer. In fast-moving fields — AI, semiconductors, space, batteries — a few months is enough for information to go stale. A useful prompt:

Summarize the notable technical issues in the semiconductor industry over the last 3 months. Conditions: only use dated sources, separate company announcements from actual research results, include source links, and flag anything unverified separately.

It's genuinely good at surfacing recent articles and what people are actually saying online. Just remember: what gets talked about a lot and what's actually significant aren't the same thing. A result trending on social media isn't automatically validated.

Strengths: fast on recent developments, good read on industry/online sentiment, well suited to fast-moving fields, easy to follow up on search results.
Weaknesses: online buzz isn't technical evidence; attention-grabbing topics can look more important than they are; source reliability still needs checking yourself.

Same question, four tools

Ask "explain the difference between the G band and 2D band in graphene's Raman spectrum" to all four, and the value-add differs by what comes next:

  • Claude Code: good for building the analysis code or plotting the data
  • Codex: good for automating the pipeline that reads and processes the Raman data files
  • Gemini: good for comparing what several papers say about it
  • Grok: good for finding recent research or news on the topic

Same question, different follow-up work, different right tool.

A workflow that's worked for me

  1. Grok — quick scan for what's currently happening in the space
  2. Gemini — pull in papers/reports and map common ground and disagreement
  3. Claude Code — check how the existing analysis code works and where it can improve
  4. Codex — automate the repetitive processing and chart generation

Current awareness → gather sources → understand the code → automate the analysis.

Head-to-head summary

Claude CodeCodexGeminiGrok
Understanding codeExcellentGoodGoodFair
Editing codeExcellentExcellentGoodGood
Automating repeat tasksGoodExcellentGoodFair
Comparing long documentsGoodFairExcellentFair
Current-events searchFairFairGoodExcellent
Technical writingGoodFairGoodFair
Reading online sentimentFairFairGoodExcellent

Bottom line

Each one has a distinct personality once you use them enough: Claude Code feels like a colleague reading code alongside you; Codex like a developer you can actually hand a task to; Gemini like an assistant who's already read the stack of reports on your desk; Grok like the person who always knows what just happened. None of it should be taken at face value, though — especially for technical work, always check three things: is there a real source, is fact separated from speculation, and do the numbers and conditions actually hold up. These tools don't replace the thinking — they cut down the time spent reading, gathering, and organizing before you get to think.

AI features and models change constantly — check each service's current documentation before relying on it for real work. The Korean version of this post is on my Naver blog.

AI Video Tools Compared: Higgsfield vs Google AI Studio vs Grok (Seedance, Veo, Kling)

Once you decide to actually make AI video instead of just watching demos, the real question isn't "which model is best" — it's "which one is best for what I'm doing right now." I spent a few weeks running the same scenes through Seedance, Veo, Kling, and Grok Imagine, then compared the platforms — Higgsfield, Google AI Studio, and Grok — that give you access to them. Short version: Seedance and Kling win on raw output quality. Grok wins on cost-per-iteration, and iteration is most of what AI video actually is.

The models, one by one

Seedance — stunning output, terrifying to iterate on

Seedance is currently one of the most impressive video models around. Character motion is smooth, camera moves read as genuinely cinematic, and multi-image reference input holds up well. A prompt like:

A woman walks slowly through a night alley in Seoul. The camera follows her from behind, moving smoothly. Neon reflects off the wet asphalt, and car lights pass in the distance. Soft cinematic music and ambient city sound.

— comes back with mood and camera work genuinely well captured. The catch is price. AI video rarely nails a shot on the first try; you generate, discard, adjust, and regenerate. When each attempt costs real money, you stop experimenting and start playing it safe — which defeats the point. Seedance is best saved for final shots you've already validated elsewhere, not for exploring ideas.

Veo — realism and physics done right

Google's Veo is strong where things need to look real : natural motion, believable lighting and texture, and (on some models) integrated audio. It's a good fit for product ads, food and lifestyle scenes, natural human performance, and anything meant to look like it was actually filmed — think a coffee ad or a car commercial.

Accessed through Google AI Studio, Veo feels less like a video app and more like a lab bench: you pick the model, manage settings, and watch credits and API cost directly. That's great if you're building something programmatic, less great if you just want to make a nice video. Editing and story-management features are limited compared to a dedicated video platform.

Kling — consistency and shot control

Kling has been a strong image-to-video option for a while, and Kling 3.0 improved character/object consistency across multiple shots, plus native audio and multi-shot storyboarding. It shines when the same character needs to reappear across cuts:

The same character sits by a cafe window. Shot one: looking at her coffee cup. Shot two: slowly looking out the window. Shot three: camera moves to her side. Face and outfit stay identical across all three shots.

Kling handled that kind of continuity better than most alternatives. Downsides mirror Seedance: high-quality mode burns credits fast, generation isn't quick, and results vary enough between runs that repeated testing gets expensive.

Grok Imagine — not the best, but the easiest to iterate on

Grok Imagine won't out-render Seedance or Veo on any single metric. What it's good at is being cheap and fast enough that you actually generate ten variations instead of agonizing over one. It's well suited to turning a still image into motion, short-form clips, quick mood/motion tests, and generally throwaway experimentation. Faces and hands wobble more often than the premium models, and it's not built for long-form storytelling — but for the "try it, discard it, try again" loop, it's the most usable option by a wide margin.

Model comparison at a glance

Seedance Veo Kling Grok Imagine
Video quality Excellent Excellent Excellent Good
Character consistency Excellent Good Excellent Fair–Good
Physics/realism Good Excellent Good Fair
Camera work Excellent Good Excellent Good
Multi-shot support Good Fair–Good Excellent Fair
Native audio/lip-sync Yes Excellent Yes No
Generation speed Moderate Moderate Moderate Fast
Cost of iterating High High High Low

The platforms

Higgsfield — everything under one roof

Higgsfield's main pitch is access: Seedance, Veo, Kling, Sora, and Grok Imagine all live behind one subscription, alongside image generation, image-to-video, character consistency tools, start/end frame control, lip-sync, and ad-focused templates. Not juggling separate subscriptions to compare models is genuinely convenient, and it's a solid fit for anyone doing serious video or music-video production. The trade-off: the monthly cost adds up, credit draw varies by model, and "unlimited" tiers rarely mean every model is unlimited — run the good models a lot and credits disappear fast. It can feel like overkill if you're just experimenting casually.

Google AI Studio — a lab, not a studio

This is where you go to work with Veo (and other Google models) directly, with API access for automation. Great for developers and anyone building a product on top of these models; a bit much if your goal is simply "make one good video," since editing and scene-management tools are minimal and repeated testing racks up API cost you have to track yourself.

Grok — the lightest way to start

Not a professional editing platform, but a genuinely easy way to turn ideas and short clips into video fast, then throw away what doesn't work. Good for beginners, short-form/social content, and anyone who wants to test a lot without spending a lot. Not built for long-form storytelling or heavy editing — you'll want another tool for the final assembly.

Platform comparison

Platform Best for Strength Weakness
Higgsfield Serious video creators Multiple models + production tools in one place Subscription/credit cost adds up
Google AI Studio Developers, experimenters Direct Veo + API access Steep learning curve for non-developers
Grok Beginners, short-form creators Simple, cheap to iterate on Limited editing/production features

Recommended combos

  • Starting out: Grok alone — test ideas and short scenes without spending much.
  • Best quality/cost balance: Draft on Grok, then send only the shots you love to Seedance or Kling on Higgsfield.
  • Realistic ad footage: Veo through Google AI Studio.
  • Building automation or a product: Google AI Studio + the Veo API.

Bottom line

Seedance and Kling are genuinely impressive — and too expensive to use freely. Grok isn't always the best output, but it's the one you can actually afford to run ten times, and in AI video, picking the best two out of ten attempts usually beats betting everything on one expensive generation. My honest recommendation: don't start by subscribing to the priciest model. Test broadly on Grok first, then spend your premium credits only on the shots that already earned it.

Pricing, generation limits, and platform features for AI video tools change frequently — check each service's current terms before subscribing. The Korean version of this post is on my Naver blog .

How to Cut AI Video Generation Costs: Draft with Grok, Finish with Higgsfield

 If you have been playing with AI video generation, you already know the pattern. The free credits feel generous for about a week. Then you try to make something you actually care about, and the credits start melting.

I make AI music videos as a hobby (my day job is managing things in the semiconductor industry, which turns out to be cheaper). Along the way I burned through more credits than I would like to admit — extra arms, faces that change between shots, cameras that wander off in the wrong direction. This post is the cost-control pipeline I ended up with after all that: draft cheap, verify early, and spend real money only on shots you have already validated.

Why AI video burns money so fast

Video is just many images in a row, so every generation costs far more compute than a still image. On top of that, cost scales with almost every knob you can turn:

  • Longer clips
  • Higher resolution
  • Generating audio together with the video
  • Premium models (Veo, Kling, Seedance)
  • Character/object consistency features
  • Generating multiple scenes in one batch

And here is the painful part: you are charged even when the result is unusable. "Surely the next one will be fine" is the most expensive sentence in AI video production.

The core principle: never prototype on a premium model

Sedance and Kling produce great footage. But using them to explore ideas is like renting a film crew to scribble a storyboard. The pipeline that works:

Idea → reference image → motion test on a cheap model → final render on a premium model

Each stage filters out failures before they reach the expensive stage. Here is each step in detail.

Step 1 - Write the scene down before generating anything

The cheapest tool in this entire pipeline is a text file. "A woman walking through a city" will give you a vague, re-roll-inviting result. Pin the scene down first:

Purpose: lonely mood, protagonist walking at night
Character: woman in her 20s, black coat
Location: rain-soaked alley, Seoul
Camera: slow tracking shot following from behind
Motion: slow walk, hair moving in light wind
Mood: cold, melancholic, cinematic
Aspect ratio: 9:16 vertical

Every ambiguity you resolve on paper is a re-generation you do not pay for later.

Step 2 - Lock the reference image first

Do not go text-to-video directly. Generate a still image first and fix everything there: face, age, hairstyle, outfit, location, time of day, framing, lighting, aspect ratio.

An image you dislike costs one cheap re-roll. A video whose character is wearing the wrong coat costs the full video price — and you will notice it only after rendering. This single checkpoint improved my quality-per-credit more than anything else in the pipeline.

Step 3 - Test motion on Grok (or any budget tier)

This is the step that saved me the most money. Before touching a premium model, I run the shot through Grok's image-to-video. Any low-cost tier works the same way — Seedance mini at 480p, Kling's budget mode, whatever you have cheap access to.

A test prompt looks like this:

The woman in this image walks slowly forward. The camera follows her from behind. Her coat and hair move naturally in a light wind. City lights reflect on the wet pavement. Calm, cinematic mood. Slow camera movement.

You are not judging image quality here. You are checking five cheap-to-verify things:

  • Does the character move in the intended direction?
  • Is the camera movement natural?
  • Is the pacing right?
  • Do the character and background work together?
  • Does the mood match the music or story?

Step 4 - Send only the winners to a premium model

Once a shot passes the motion test, re-generate it properly. I use Higgsfield for this stage because it exposes Seedance, Veo, and Kling in one place, so the same image + prompt can be compared across models. My rough routing:

NeedModel
Character motionKling
Cinematic camera workSeedance
Realistic scenes + audioVeo
Fast, cheap idea testsGrok

Not every shot needs the top model. Routing by need means only a fraction of your footage is rendered at premium prices.

(Examples of Grok only video : https://youtube.com/shorts/92xqMIJYx3s?feature=share )

Step 5 - Generate short clips, not long ones

One 15-second generation fails more often, and more expensively, than four 4–6-second clips. Break the scene into cuts — "she stands at the alley entrance", "she walks in", "camera tracks her profile", "she stops and looks up" — then join them in your editor. Shorter clips fail cheaper and re-roll faster. (Some people report that Seedance handles action sequences better as one longer clip, so treat this as a default, not a law.)

Step 6 - Add audio in post, not in the model

Built-in audio generation is convenient and quietly expensive, because every re-roll regenerates the audio too. For music videos and short-form content, drop music and SFX in during editing instead. During generation, you only need to validate motion, camera, transitions, and lighting.

Step 7 - Keep a failure log

AI video punishes you for repeating mistakes, so write them down. Mine includes:

  • Camera path specified too aggressively
  • Too many character actions packed into one shot
  • Prompt description contradicting the reference image
  • Lighting and background descriptions fighting each other
  • One giant run-on prompt sentence

If you work with an AI coding/agent tool, put this log into its instructions or skill file and tell it to stop you from repeating them. Prompt-writing skill matters, but reducing your failure rate matters more.

Recommended pipelines by use case

Use casePipeline
BeginnerImage gen → Grok image-to-video → edit
Best cost/quality balanceImage gen → Grok motion test → Kling or Seedance via Higgsfield
High-end ad footageImage gen → Veo or Seedance → separate edit + sound
Music videoCharacter images → Grok scene tests → premium models for keepers → edit

Seven ways to waste credits (ask me how I know)

  1. Running a premium model on a half-written prompt
  2. Packing too many actions into one shot
  3. Generating long clips in one go
  4. Letting the image and the prompt describe different characters
  5. Endlessly "fixing" a generation that was never going to work
  6. Testing across multiple accounts without tracking free credits
  7. Maxing out resolution and audio on every draft

The last one is sneakier than it looks. Draft at low resolution to check motion and composition; re-render only the final picks in high quality.

Bottom line

AI video is not a one-click product; it is an iterative process of generating, discarding, and refining. That makes cheap iteration the most valuable feature a tool can have. My honest summary: Seedance and Kling are excellent — and too expensive to iterate on freely. So I test as much as possible on Grok, and re-render only the shots I already love on Higgsfield's premium models.

  1. Write the scene down
  2. Lock a reference image
  3. Test motion on a cheap model
  4. Pick the winners
  5. Final render on a premium model
  6. Music and SFX in the edit

Pricing, generation limits, and features of AI video platforms change frequently — check each service's current pricing before subscribing.

2023년 10월 19일 목요일

C# RichTextBox를 활용하여 이벤트 진행사항 업데이트하기

동기/비동기 모두 사용 가능.
   
private void _InsertMessage(string s)
{
    string strDatetime = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss");
    if (RichTextBox.InvokeRequired)
    {
        RichTextBox.BeginInvoke(new Action(() => RichTextBox.AppendText("[ " + strDatetime + "] : ")));
        RichTextBox.BeginInvoke(new Action(() => RichTextBox.AppendText(s + System.Environment.NewLine)));
        RichTextBox.BeginInvoke(new Action(() => RichTextBox.ScrollToCaret()));
    }
    else
    {
        RichTextBox.AppendText("[ " + strDatetime + "] : ");
        RichTextBox.AppendText(s + System.Environment.NewLine);
        RichTextBox.ScrollToCaret();
    }
}   

C# PictureBox에서 마우스 우클릭으로 clipboard에 복사하기 기능 추가

 


private void PICVIEW_MouseClick(object sender, MouseEventArgs e)
{
	if (e.Button == MouseButtons.Right)
	{
		ContextMenu ctxM = new ContextMenu();
		Point mousePoint = new Point(e.X, e.Y);
		MenuItem m1 = new MenuItem();
		m1.Text = "Copy Image";
		
		ctxM.MenuItems.Add(m1);
		ctxM.Show(PICVIEW, mousePoint);
		
		m1.Click += (senders, es) =>
		{
			Clipboard.SetImage(m_PicViewImage); //m_PicViewImage ==> One of image file
		};
	}
}

2023년 10월 18일 수요일

여권 로마자 (영어 스펠링) 성(이름) 바뀌었을 때, 운전 면허증 (영문 이름) 변경

어릴 때 만들었던 여권에 표기된 내 성은 CHUNG. 

하지만 대학원 연구실에서 부터 그리고 논문 출판이 나올 때까지 줄 곧 Jung을 성으로 쓰고 있어 언젠가 바꾸고 싶다는 생각을 가지고 있었으나, 특수한 몇 가지 조건 없이 여권에 로마자 표기를 바꾸는 것은 꾀나 까다로운 일이다. 

하지만 로마자 표기를 바꿀 수 있는 몇 가지 요건 등이 있는데, 검색 결과 그래도 가장 확실한 것은 다음의 경우라고 한다. (그 외의 경우는 다음의 링크 참고 : https://www.passport.go.kr/home/kor/contents.do?menuPos=39 )


즉, 자녀의 여권을 원하는 성으로 표기해서 만들고 항공권을 예매해서 이를 증빙 서류로 활용하여 변경 신청하는 방법이다. 

이때 주의 할 것은 항공권을 구매할 때, 바꾸고자 하는 성으로 티켓을 끊어야 한다는 것이다. 

예를 들어 내가 바꾸고자 하는 성의 로마자 철자는 CHUNG-->에서 JUNG으로 바꾸고자 하는 것인데 항공권 구매할 때, JUNG으로 진행해야 한다는 사실. 아,,, 이것 때문에 바쁘시간 쪼개서 찾은 여권 민원실을 다른 날짜에 다시 방문해야 하는 아찔한 상황이 벌어질 뻔 했으나 재빨리 회사와 연계된 여행사에 연락해서 급하게 다시 항공권 티켓을 끊고, 겨우 같은 날 진행할 수 있었다. (다행스럽게도 찾아간 날이 목요일, 해당 구청이 저녁까지 운영하는 날이었다. )

우여곡절 끝에 서류를 모두 넣고, 담당 직원 분께서 외교부 심사가 길게는 2~3주가 걸릴 수 있다고 하셨으나 다행스럽게도 일주일 만에 외교부 심사가 완료되고 최종 여권이 나오기 까지 외교부 심사 1주일, 여권 처리기간 4일 (목/금/월/화) 만에 여권이 발급되었다.


여권 상에 성이 바뀌었으니 운전면허증 (작년 12월에 갱신하면서 영문면허증도 같이 발급 받았는데 CHUNG으로 발급을 받았었다. ㅠ.ㅜ) 도 재발급이 필요해서 바로 용인운전면허시험장으로 이동했고, 다행스럽게도 복잡한 절차 없이 재발급이 가능했다. 기타 필요한 서류 없이 구두로 설명 해드렸더니 아주 친절하게 빠르게 발급 해주셨다. 접수부터 운전면허 재발급까지 3분? ㅎㅎㅎ 와우~


이것으로 나의 성을 되찾을 수 있었으니~
별거 아니지만 굉장히 홀가분한 이기분~

2016년 8월 2일 화요일

C# Textbox example

if (k == 0)
                {
                    textBox1.Text = "c" + Convert.ToString(k) + "; 
                    x0, y0, R = " + Convert.ToString(cir[k].x0) + ",\t" +
                Convert.ToString(cir[k].y0) + ",\t" + Convert.ToString(cir[k].Radius);
                    textBox2.Text = "c" + Convert.ToString(k) + "; 
                    a1, a2, f1, f2 = " + Convert.ToString(a1_Round[k]) +
                        ", " + Convert.ToString(a2_Round[k]) + ", " + Convert.ToString(f1_Round[k]) + ", " + Convert.ToString(f2_Round[k]);
                }
                else
                {
                    textBox1.Text += System.Environment.NewLine + "c" + Convert.ToString(k) + "; 
                    x0, y0, R = " + Convert.ToString(cir[k].x0) + ",\t" +
                Convert.ToString(cir[k].y0) + ",\t" + Convert.ToString(cir[k].Radius);
                    textBox2.Text += System.Environment.NewLine + "c" + Convert.ToString(k) + "; 
                    a1, a2, f1, f2 = " + Convert.ToString(a1_Round[k]) +
                        ", " + Convert.ToString(a2_Round[k]) + ", " + Convert.ToString(f1_Round[k]) + ", " + Convert.ToString(f2_Round[k]);
                }
test
for (int x = 0; x < 5; x++)
{
}
\t  ==> tap 삽입
System.Environment.NewLine ==> 새 줄로 시작

2016년 2월 11일 목요일

C#에서 linear algebra 계산을 위한 무료 라이브러리

http://numerics.mathdotnet.com/

설치 방법은 간단합니다.

Visual C#을 실행시키신 후 라이브러리를 사용하려는 프로젝트에서

다음과 같이 패키지를 추가하시면 됩니다.


















패키지 관리자 콘솔에 다음과 같이 입력 후 Enter

PM> Install-Package MathNet.Numerics



아래는 콘솔을 사용한 간단한 예제 입니다.
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MathNet.Numerics.LinearAlgebra;
using MathNet.Numerics.LinearAlgebra.Double;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            Matrix A = DenseMatrix.OfArray(new double[,] {
                {1,1,1,1},
                {1,2,3,4},
                {4,3,2,1}});

            Vector[] nullspace = A.Kernel();

            // verify: the following should be approximately (0,0,0)
            //(A * (2 * nullspace[0] - 3 * nullspace[1]));
            Console.WriteLine(A * (2 * nullspace[0] - 3 * nullspace[1]));




            var C = Matrix.Build.DenseOfArray(new double[,] {
                { 3, 2, -1 },
                { 2, -2, 4 },
                { -1, 0.5, -1 }            });

            //Linear equation Example
            var b = Vector.Build.Dense(new double[] { 1, -2, 0 });
            var x = C.Solve(b);


            //Singular value decomposition
            var svd = C.Svd(true);
            
            Console.WriteLine(svd.U);
            Console.WriteLine(svd.W);
            Console.WriteLine(svd.VT);

            Console.ReadKey();
        }
    }
}





실행 결과

















이제는 매트랩 없이도 편하게 행렬식을 다룰 수 있겠군요.

이거 땜에 날아간 나의 시간들 ...   ㅠ.ㅜ

2016년 1월 27일 수요일

Visual C# (3) 서로 겹쳐지지 않는 원 그리기 (Non Overlapped Circle Drawing)

안녕하세요?

이곳에 포스팅을 한지도 벌써 일년이 넘었군요 ^^;; 

간만에 글을 남기긴 하지만 내용 자체는 지난 포스팅에 이어 계속 원을 그리는 것을 계속 해보도록 하겠습니다.

 이번에 포스팅할 내용은 원을 여러개 그리는데 서로 겹쳐지지 않게끔 그리는 것이 목표입니다. 이번에는 클래스를 이용해서 프로그램을 짤 건데요, 원의 중심점과 반지름 등을 이용하여 Circle 객체를 생성 한 후 각 객체가 서로 겹쳐지지 않게끔 검사를 해주고 최종적으로 각 원이 차지하는 픽셀을 White로 칠해주는 프로그램입니다.

 Circle 객체를 생성할 때에는 객체가 가지는 요소에 원의 중심점, 원의 반지름의 값을 설정하면 그려질 원이 차지하는 픽셀 영역의 집합을 계산하는 메소드를 넣는거 까지 Circle class가 하게 될 역할 입니다.

 그리고 CircleDraw class도 만들어 줄 건데요, 이 CircleDraw class는 원이 생성될 갯수를 설정해주면 각 객체가 생성될 때 마다 이전에 생성된 Circle 객체와 서로 겹쳐지지 않는 지를 검사하고 겹쳐지지 않는 것이 확인되면 최종적으로 원들이 차지하는 픽셀 영역의 집합에 새로운 원의 영역을 추가하는 것으로 마무리를 짓습니다.

뭐 코드는 안 보여드리고 쓸데없이 서두가 길었는데요,

일단 코드를 쭉 보시죠~


using System;
using System;
using System.Collections.Generic;
using System.Linq;


namespace NonOverlapCircleDrawing
{       
    class Circle
    {     
        double x0 { get; set; }
        double y0 { get; set; } //원의 중심 좌표
        double R { get; set; }  //원의 반경

        public HashSet hashCircleAreaIndex { get; set; }

        public Circle(double x, double y, double Radius)
        {
            this.x0 = x;
            this.y0 = y;
            this.R = Radius;
        }

        //원의 중심 좌표와 반경만 주어지면 원이 그려질 픽셀을 hashset에 넣어주는 기능을 하는 메소드
        //List, Array list 등을 사용할 수도 있지만 contain 검색 및 삭제 추가 시 시간이 더 많이 소요됨.
        public void CircleGeneration(int ImgW, int ImgH)
        {
            hashCircleAreaIndex = new HashSet();
            for (int Y = (int)(y0 - R); Y < (y0 + R); Y++)
            {
                for (int X = (int)(x0 - R); X < (x0 + R); X++)
                {
                    if (X >= ImgW || X < 0) continue;
                    if (Y >= ImgH || Y < 0) continue;
                    if ((X - x0) * (X - x0) + (Y - y0) * (Y - y0) < R * R) hashCircleAreaIndex.Add(ImgW * Y + X);
                }
            }
        }
    }


    class CircleDraw
    {        
        Circle[] cir { get; set; }
        double[] rawImage { get; set; }
        int ImgW { get; set; }
        int ImgH { get; set; }

        public List listCircleAreaIndex { get; set; } //중복되지 않는 Random Number를 생성하기 위해 꼭 필요함
        public HashSet hashCircleAreaIndex { get; set; } //Circle 객체를 차례로 생성함에 따라 각 객체가 차지하는 pixel index를 저장하는 hashset
        public HashSet hashTest; //listCircleAreaIndex와 연동하기 위한 hashset. List 하나로 처리해도 구동은 가능하나 contain 검색시나 foreach 구문 시 속도가 너무 느려 그 때만 이 hashset 이용

        public CircleDraw(int ImgW, int ImgH)
        {
            this.ImgW = ImgW;
            this.ImgH = ImgH;
        }

        //listCircleAreaIndex와 hashTest를 모든 픽셀 인덱스로 차례로 채워 넣기 위한 기능 수행
        public void ListGen()
        {
            int k = 0;
            listCircleAreaIndex = new List();
            hashTest = new HashSet();

            for (int j = 0; j < ImgH; j++)
            {
                for (int i = 0; i < ImgW; i++)
                {
                    listCircleAreaIndex.Add(k);
                    hashTest.Add(k);
                    k++;
                }
            }
        }

        //겹치지 않는 원을 그리기 위한 실제적인 기능을 하는 메소드
        //CircleNumber는 그리려는 원의 갯수 설정
        public void CircleGen(int CircleNumber)
        {
            cir = new Circle[CircleNumber];
            hashCircleAreaIndex = new HashSet();
            
            Random rnd = new Random(); // Random number를 사용하기 위한 구문

            for (int CirNo = 0; CirNo < CircleNumber; CirNo++)
            {
                RETRY: //순차적으로 원을 그릴때 이전의 원과 겹치게 되면 다시 되돌아가는 기능을 하게 하는 goto 구문
                int iRndNumber = rnd.Next(0, listCircleAreaIndex.Count); //list가 가진 숫자내에서 랜덤  넘버를 생성하기 위해 필요
                int iPositionIndex = listCircleAreaIndex[iRndNumber]; //list 내에서 임의의 인덱스 추출. 그리고 이 임의의 인덱스는 원의 중심 좌표로 변환. 

                //리스트에서 추출한 인덱스로부터 원의 중심 좌표 계산
                int x = iPositionIndex % ImgW;
                int y = iPositionIndex / ImgW;
                int R = rnd.Next(15, ImgH / 10); // 반지름에 대한 랜덤넘버 생성

                cir[CirNo] = new Circle(x, y, R); //생성된 원의 중심과 반지름을 이용하여 Circle 객체 생성
                cir[CirNo].CircleGeneration(ImgW, ImgH);

                //생성된 Circle 객체가 차지하는 픽셀마다 검사하면서 이전에 생성한 Circle 객체와 겹치는 부분이 있는지 확인.
                //만약 겹치는 부분이 없는 것이 확인되면 해당되는 각 픽셀 포지션을 기존의 리스트(여기선 우선 hashTest)에서 삭제.
                foreach (int i in cir[CirNo].hashCircleAreaIndex)
                {
                    if (CirNo != 0)
                    {
                        if (hashCircleAreaIndex.Contains(i)) goto RETRY;
                        else hashTest.Remove(i);
                    }
                }

                //변환된 hashTest 값을 리스트에 그대로 대입
                listCircleAreaIndex = hashTest.ToList();

                //끝으로 나중에 최종 그림을 그려줄 때 쓰일 원이 차지하는 픽셀의 집합(hashCircleAreaIndex)에 새로 생성된 원의 픽셀 인덱스 추가
                foreach (int i in cir[CirNo].hashCircleAreaIndex)
                {
                    hashCircleAreaIndex.Add(i);
                }
            }
      
        }
    }
}





그리고 이 class들을 이용할 main winform 코드 입니다.

using System;
using System.Threading.Tasks;
using System.Drawing;
using System.Windows.Forms;

namespace NonOverlapCircleDrawing
{
    public partial class MAIN_FORM : Form
    {
        public Graphics g;
        Bitmap bmpCircle;

        public MAIN_FORM()
        {
            InitializeComponent();
        }

        private void BTN_CIRCLE_GENERATE_Click(object sender, EventArgs e)
        {            
            int ImgW = 1024;
            int ImgH = 1024;
            int iCircleNumber = 100;

            bmpCircle = new Bitmap(ImgW, ImgH);

            g = Graphics.FromImage(bmpCircle);
            g.FillRectangle(Brushes.Black, 0, 0, bmpCircle.Width, bmpCircle.Height);

            CircleDraw cirDraw = new CircleDraw(ImgW, ImgH);
            cirDraw.ListGen();
            cirDraw.CircleGen(iCircleNumber);

            foreach(int i in cirDraw.hashCircleAreaIndex)
            {
                int x = i % ImgW;
                int y = i / ImgW;
                if (i >= ImgW * ImgH) return;
                bmpCircle.SetPixel(x, y, Color.White);
            }

            PIC_BOX1.Image = (Image)bmpCircle.Clone();
        }
    }
}




그리고 프로그램 구동 모습입니다.



간만에 포스팅을 했더니 설명이 너무 마구리라

혹시나 이상한 점이나 수정해야할 점 더 좋은 코멘트 있으면 글 남겨 주세요.

당연히 질문도 환영이구요~ ^^

읽어주셔서 감사합니다.