Electrons That Flow Like Water: Vortices and Supersonic Shock Waves in Graphene

 We say electricity "flows" a dozen times a day. But the electrons in a copper wire don't flow — not the way water does.

When water moves through a pipe, the molecules collide with each other constantly and move together: fast in the middle, slow near the walls, eddies in the corners. That's what "flow" means. Electrons in a wire do something else entirely. Each one ricochets off impurity atoms and vibrating lattice ions like a pinball, paying no attention to its neighbors. There's a faint average drift in one direction, but calling it flow is generous.

Cory Dean at Columbia put the difference in one line: "Water is seeing nothing but other water." Electrons don't see each other. So they don't flow.

Except — as a February 2026 Quanta Magazine feature laid out — over the past few years physicists have actually made electrons flow like water. They've watched electron whirlpools, and they've driven an electron fluid supersonic and produced a shock wave. This post is about how that became possible and what it means.

Left: an ordinary copper wire. Electrons (blue) zigzag off impurities (grey) and the vibrating lattice. Right: ultraclean graphene. Electrons collide mainly with each other and move as a single fluid — fast in the center, slow at the walls, a vortex in the corner.

Why electrons normally can't be a fluid

A fluid needs one condition: its members must collide with each other far more often than with anything else. Water molecules hit other water molecules overwhelmingly more often than they hit the pipe wall. Those collisions exchange momentum and produce collective motion — "let's all go this way." That's a fluid.

In copper, the order is reversed. Before an electron can hit another electron, it hits an impurity atom or a thermal lattice vibration (a phonon). Each collision hands momentum to the lattice. That momentum loss iselectrical resistance. With no chance to share momentum with neighbors, no collective motion emerges. Every electron for itself. Pinball.

So the recipe for a fluid of electrons is clear: a material with almost no impurities and suppressed lattice vibrations — so clean that the only thing an electron can hit is another electron. Soviet physicist Radii Gurzhi predicted the consequences theoretically in 1963. No such material existed, so it stayed on paper for forty years.

The answer came out of a pencil

That material arrived in 2004: graphene, a single atomic layer of carbon in a honeycomb lattice, peeled off graphite with sticky tape.

What makes graphene special is near-perfect atomic order. You aren't growing a crystal and hoping for purity — you're lifting one layer off an already perfect crystal, so impurity density is tiny. Encapsulate it in hexagonal boron nitride and the environment is screened out too. For the first time, electrons hit each other before they hit anything else.

2017, Geim's group: warm it up, resistance goes down. They carved graphene into a narrow channel, ran current, and raised the temperature. In any normal metal, higher temperature means more lattice vibration and higher resistance. Here it dropped. Warmer electrons collided with each other more often, and that steered them away from the walls into a smooth central stream — the same Poiseuille flow as water in a pipe, fast in the middle, slow at the edges. Exactly what Gurzhi predicted 54 years earlier. It's now called the Gurzhi effect.

2022, Weizmann Institute: whirlpools, directly imaged. They shaped tungsten diselenide into a channel with round side chambers — Mickey Mouse ears. If the electrons are a fluid, the main current passing the chamber should spin up a backward-rotating vortex inside it, like an eddy in a river's backwater. They imaged current circulating backward in the chamber. Pinball electrons cannot do that.

2025: a supersonic shock wave made of electrons

This is the experiment that made me want to write this post.

Johannes Geurs, in Dean's lab at Columbia, carved bilayer graphene into the shape of a rocket engine nozzle — specifically a de Laval nozzle: wide inlet, narrow throat, flaring outlet. An hourglass on its side.

Graphene carved into a rocket-nozzle shape. Electron fluid accelerates through the throat past the "speed of sound" for electrons, slams into slower fluid downstream, and forms a shock front (orange). The probe above is an atomic force microscope tip mapping it.

Rocket nozzles have that shape for a reason: gas reaches the speed of sound at the throat and goes supersonic in the flaring section. It's how rockets work.

An electron fluid has its own "speed of sound" — the speed at which density disturbances propagate — roughly 300 km/s in graphene. Geurs pushed electron fluid through the nozzle. Electrons accelerated through the throat exceeded that speed, then plowed into slower electrons downstream, compressing into a shock wave. A sonic boom, inside a sheet of carbon two atoms thick.

They saw it by scanning an atomic force microscope tip over the surface to read out electric field variations, and mapped where the shock front stood. Thomas Scaffidi at UC Irvine called it "really the frontier right now."

	Ordinary metal (copper wire)	Ultraclean graphene
Electrons mostly collide with	Impurities, lattice vibrations	Other electrons
Momentum	Lost to the lattice every collision	Conserved among electrons
Motion	Pinball (every electron for itself)	Fluid (collective)
Raise temperature	Resistance rises	Resistance falls (Gurzhi effect)
At a corner	Nothing	Vortex
Through a narrow throat	Nothing	Supersonic acceleration + shock

Meanwhile in India: a textbook law broken 200-fold

Columbia isn't the only place this is happening. In 2025, Arindam Ghosh's group at the Indian Institute of Science reported in Nature Physics that ultraclean graphene violates the Wiedemann–Franz law.

That law has held since 1853: a metal that conducts electricity well also conducts heat well, because electrons carry both, so electrical and thermal conductivity scale together. It's why a silver spoon in hot soup heats up fast. But tuned to graphene's Dirac point — the boundary between metal and insulator — electrical conductivity went up while thermal conductivity went down. At low temperature the mismatch exceeded the law's prediction by more than 200 times.

Same root cause: electrons moving not as individual particles but as an extremely low-viscosity fluid. Researchers call this state a Dirac fluid, and mathematically it behaves like the quark–gluon plasma produced in particle accelerators. A sliver of pencil lead imitating the early universe.

What this has to do with your life

Honestly: nothing yet. This needs cryogenic temperatures, ultraclean material, and engineered geometry all at once, and it's a long way from a phone. But three directions matter.

1. A new floor for resistance. Pinball resistance is set by impurities. Fluid resistance is set by the shape of the channel, the way a pipe's diameter governs water flow. In theory, hydrodynamic flow can have lowerresistance than ballistic transport, where electrons hit nothing at all. That opens the idea of designing circuits as plumbing rather than wiring.

2. A handle on materials nobody could explain. Strange metals near high-temperature superconductors have defied conventional electron theory for decades. The view that they may be electron fluids of some kind is gaining ground. Andrew Lucas at the University of Colorado calls it "something that can't be explained in any textbook paradigm."

3. A different way to compute. Instead of tracking 10²³ electrons individually, you describe the system with a handful of fluid variables — density, viscosity, pressure. In an earlier post I wrote about quasiparticles, where treating a wave as a particle makes the math tractable. This is the mirror image: treating particles as a fluid makes a different class of problems tractable.

What stayed with me

Study solid-state physics long enough and you keep rediscovering how conditional the statement "an electron is a particle" really is. Particle-like behavior isn't the electron's nature — it's how electrons behave when the surroundings are too messy for them to talk to each other. Clean up the environment and they flow, swirl, and shock like water.

Gurzhi predicted this in 1963. The material that could test it appeared 41 years later, and the first experiment took another 13. The theory wasn't wrong; the material didn't exist. I see the same thing working in the semiconductor industry: the gap between "theoretically possible" in a textbook and "reproducible on a production line" is, most of the time, a question of how clean you can make it. We live less in an age of theory than in an age of cleanliness.

References

• Quanta Magazine, "Physicists Make Electrons Flow Like Water" (Feb 11, 2026)
• Aniket Majumdar et al., "Universality in quantum critical flow of charge and heat in ultraclean graphene," Nature Physics 21, 1374 (2025). DOI: 10.1038/s41567-025-02972-z
• D. A. Bandurin et al., "Negative local resistance caused by viscous electron backflow in graphene," Science 351, 1055 (2016)

This post explains published research for a general audience; see the sources 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.

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
Cause	Electrons leaking along grain boundaries	Hydrostatic pressure of lithium in cracks
Ahead of the dendrite tip	Lithium should already be plated	Should be clean
Observed	No plating ✗	Clean + stress signatures ✓
Everyday analogy	Mold growing inside a wall	Waterjet cutting rock
Prescription	Block electron conduction	Tougher 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.

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.

Plan	Monthly billing	Annual (per month)	Savings	Credits / month
Starter	$15	$15	0%	~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 models, until 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.

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 Code	Codex	Gemini	Grok
Understanding code	Excellent	Good	Good	Fair
Editing code	Excellent	Excellent	Good	Good
Automating repeat tasks	Good	Excellent	Good	Fair
Comparing long documents	Good	Fair	Excellent	Fair
Current-events search	Fair	Fair	Good	Excellent
Technical writing	Good	Fair	Good	Fair
Reading online sentiment	Fair	Fair	Good	Excellent

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:

Need	Model
Character motion	Kling
Cinematic camera work	Seedance
Realistic scenes + audio	Veo
Fast, cheap idea tests	Grok

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 case	Pipeline
Beginner	Image gen → Grok image-to-video → edit
Best cost/quality balance	Image gen → Grok motion test → Kling or Seedance via Higgsfield
High-end ad footage	Image gen → Veo or Seedance → separate edit + sound
Music video	Character 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.

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
		};
	}
}

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

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

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

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

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

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

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

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

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

이것으로 나의 성을 되찾을 수 있었으니~

별거 아니지만 굉장히 홀가분한 이기분~

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 ==> 새 줄로 시작

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();
        }
    }
}

실행 결과

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

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