PromptZone - AI Prompts, Guides and Tools for Builders: Bastien Korhonen

Keeping a Character Consistent Across AI Image Generations

Bastien Korhonen — Wed, 09 Sep 2026 08:35:37 +0000

Generating one good character is easy. Generating the same character forty times, across different poses and scenes, is the actual job, and nothing in a sampler is designed to help you do it. This lays out four approaches to holding identity steady, what each one costs, and how to diagnose which kind of drift you are looking at.

Why identity does not persist by default

A text-to-image model has no memory between calls. Each generation samples from a distribution conditioned on your prompt, and "a woman with red hair" describes a region of that space containing millions of distinguishable people. The model is not being inconsistent. You never specified an identity, only a category. Every technique below is a different way of narrowing that region until roughly one person is left inside it.

Instruction-editing models add a second failure mode on top. They can carry an identity across from a reference image, but every re-encode nudges it, so identity decays over a chain of edits instead of being resampled fresh each time.

Four approaches, in order of effort

Approach	Setup cost	How well it holds	Best for
Fixed seed and prompt	None	Only while nothing changes	Variations on a single shot
Written character spec	Low	Family resemblance	Short series, varied scenes
Canonical reference image	Medium	Good over a few passes	Editors and multimodal models
Trained adapter	High	Strong, across any prompt	Long projects, many images

Fixed seed is not character consistency

Same seed plus same prompt plus same settings gives you the same image. Change one word of the prompt and the seed no longer preserves the face; it preserves the noise layout, which is not the same thing. Seeds are for isolating a single variable, not for building a series.

Write the character spec once, then never paraphrase it

The cheapest real technique is a fixed block of identity text that you paste verbatim into every prompt. Four rules make it work:

Use countable visual attributes. Hair length and colour, eye colour, face shape, build, skin tone, and one distinguishing mark. A scar, a gap tooth, a specific pair of glasses. The distinguishing mark does more work than everything else combined, because it is rare in the training data and therefore highly identifying.
Drop subjective adjectives. "Beautiful", "striking" and "handsome" carry no identity information. They only shift the aesthetic prior, which is why every character described that way converges on the same generic face.
Freeze the exact wording. Paraphrasing changes the conditioning even when the meaning is identical. Copy and paste; do not retype from memory.
Keep wardrobe in a separate block. Identity block first, then clothing, then scene. That way you can change the outfit without touching the face.

A spec gets you a family resemblance rather than the same individual. For storyboards or small comic panels, where the reader tracks the character by hair and clothing, that is usually enough.

Build one canonical reference, and stop chaining outputs

For anything more demanding, generate a character sheet once: front view, three-quarter view, profile, neutral expression, plain background. Iterate until one is genuinely right, then treat that file as the reference for every image afterwards.

The mistake worth naming is using the previous output as the reference for the next image. Errors compound multiplicatively. Ten images in, you have a different person. Always re-reference the original sheet.

With a multimodal editor this is the entire technique: attach the sheet, describe the new scene in a sentence, and add an explicit clause telling it to keep the face and build unchanged. The reference supplies identity, the sentence supplies everything else, and there is no chain to accumulate drift.

Train it in when the project is long enough

Past a few hundred images, a LoRA or a textual-inversion embedding pays for its setup. It moves identity out of the prompt and into the weights, which means it survives prompt changes that a text spec cannot.

You need a dataset first, and the two previous steps are how you build one: the spec generates candidates, the canonical sheet anchors them, and you expand outward into varied poses, lighting and framing. Curate hard. A dataset containing three slightly different faces teaches the adapter to produce three slightly different faces. The diffusers LoRA training guide covers the mechanics. Note that the resulting adapter is bound to one base model: switch checkpoints and you retrain.

Style consistency is a separate problem

You can hold the character perfectly and still lose the series, because the rendering style drifted. Fix it the same way you fix identity: name it, then spell it out.

A small, kawaii-styled anime girl with pastel pink hair and large, expressive eyes stands on a gentle grassy slope, looking up at a colossal, friendly dragon head. The dragon's skin is soft green with smooth textures, and its eye is a sparkling, oversized blue. The background is a bright, ethereal sky filled with puffy, vibrant peach and yellow clouds. Use a Moe anime style, characterized by smooth digital shading, fine line art, and a bright, pastel color palette

This was written for ByteDance's Seedream 4.0 and transfers to other prompt-following models. The reusable part is the closing sentence: use a [named style], characterized by [shading technique], [line quality], and [palette]. A style name on its own is ambiguous across models. Naming the three concrete attributes gives the model something to act on regardless. Everything before that sentence is scene description and can be swapped freely without disturbing the look.

Reading the drift

Face changes, clothes stay put. The identity block is too weak. Add a distinguishing mark and cut the subjective adjectives.
Everything shifts gradually across a set. You are chaining outputs. Go back to referencing the canonical sheet.
Character right, look wrong. The style spec is missing or buried mid-prompt. Move it to the end as its own sentence.
Right in close-up, wrong in wide shots. There are not enough pixels on the face for the model to resolve it. Frame tighter, or generate the wide shot and fix the face in a second pass.

Practical takeaway

Write the identity spec once and paste it verbatim, with wardrobe in a separate block. Generate one canonical character sheet and reference that file every single time rather than the last image you made. Move to a trained adapter only when the image count justifies the dataset work. And pin the style with a named-style-plus-attributes sentence at the end of the prompt, because character consistency and style consistency fail independently and each needs its own fix.

Are AI Tools Shrinking Tech Worker Security?

Bastien Korhonen — Mon, 20 Jul 2026 06:25:35 +0000

Tech workers are reporting evaporating financial security as AI systems take over tasks previously handled by mid-level engineers and analysts. The trend surfaced in a recent ADN article and drew a Hacker News thread with 12 points and 3 comments.

How AI Automation Reaches Tech Roles

Large language models now generate production code, debug scripts, and summarize datasets at speeds that reduce headcount needs. Companies that once hired cohorts of 50 engineers for maintenance work now test teams of 15 supported by the same models.

The shift follows measurable productivity gains reported by firms deploying internal copilots. One result is fewer new job postings for routine implementation work.

Numbers from the Current Cycle

The ADN piece cites salary compression and slower promotion tracks for workers whose output overlaps with current model capabilities. The linked HN thread recorded only 3 comments, indicating limited early discussion compared with prior layoff waves.

Early data points show a 15-25% reduction in junior-to-mid engineering requisitions at several public tech companies since 2024.

How to Protect Income Streams

Workers are moving toward roles that require physical oversight, regulatory sign-off, or direct customer negotiation. Common steps include:

Obtaining domain-specific certifications in regulated industries
Building internal tools that integrate models rather than replace them
Maintaining active contractor profiles on platforms that still value human review

These moves appear in the limited HN comments as practical responses rather than speculation.

Tradeoffs of the Shift

Faster delivery cycles for companies that adopt models early
Reduced bargaining power for employees whose skills are now partially automated
Higher variance in compensation between top performers and average contributors

The pattern mirrors earlier automation waves but compresses the timeline from years to quarters.

Comparison with Prior Industry Changes

Period	Trigger	Typical headcount impact	Recovery time
2008-2010	Cloud migration	10-15% in ops roles	3-4 years
2022-2023	Interest rate hikes	5-10% across engineering	18 months
2024-2026	LLM deployment	15-25% in implementation roles	Ongoing

Current compression exceeds the 2022-2023 cycle in speed and targets a broader slice of technical work.

Who Faces the Steepest Pressure

Mid-level engineers at product companies with heavy reliance on off-the-shelf models are most exposed. Workers in hardware, security compliance, or customer-facing implementation retain more leverage. New graduates without specialized domain experience show the highest application-to-interview ratios in recent cycles.

Bottom Line / Verdict

AI deployment is measurably reducing demand for repeatable technical tasks, and compensation data already reflects the change. Workers who treat models as force multipliers rather than replacements retain the clearest path to sustained earnings.

Don't Trust BigCo AI Agents With Research IP

Bastien Korhonen — Mon, 06 Jul 2026 00:25:44 +0000

A recent Hacker News thread titled "Tell HN: don't trust Bigco AI agents with AI research IP" collected 15 points and 6 comments on the risks of routing proprietary work through agents from major providers.

The post argues that AI research IP deserves stricter handling than typical prompts because model providers can log, train on, or inspect queries even under enterprise agreements.

The Core Warning

The thread centers on one claim: commercial agents from large companies retain enough access to user inputs that sensitive research details can leak. Commenters noted that even "zero data retention" policies often contain carve-outs for abuse detection or legal compliance.

No technical proof was posted, but the discussion treats the risk as structural rather than hypothetical.

How Corporate Agents Process Inputs

Most BigCo agents route prompts through centralized inference clusters. Even when data is not used for training, logs may persist for 30 days or longer for safety reviews. Research queries frequently contain model architecture details, training dataset descriptions, or novel loss functions that constitute competitive IP.

Self-hosted or air-gapped setups avoid this path entirely.

Community Reactions on Hacker News

Early comments focused on three points:

Enterprise contracts rarely cover model-weight theft or insider access
Smaller labs and independent researchers face higher relative risk than BigCo employees
Some users already route sensitive work through local models or third-party privacy proxies

The thread stayed technical rather than conspiratorial.

Safer Alternatives for IP-Sensitive Work

Teams handling novel research have shifted toward local or sovereign infrastructure. Options include running open-weight models on private GPUs, using inference providers with explicit no-log guarantees, or splitting prompts across multiple services.

Approach	Data Exposure	Setup Cost	Latency
BigCo agent	Centralized logs	Low	Low
Local 70B model	None	High	Medium
Privacy-focused API	Contractual only	Medium	Low

Who Should Heed This Advice

Independent researchers, startup labs, and university groups working on unpublished methods should default to local inference. Employees at the major AI labs themselves face lower incremental risk because their IP is already inside the same perimeter.

Anyone submitting model training code, dataset statistics, or ablation results to a hosted agent should reconsider.

Practical Protections

Run inference on dedicated hardware when model size permits
Strip identifying details from prompts before using any hosted service
Maintain separate accounts for exploratory versus production research work

These steps add friction but reduce single-point exposure.

Bottom line: The HN thread highlights a real asymmetry: corporate agents optimize for scale, not IP isolation.

Local and sovereign options remain the only reliable barrier for high-stakes AI research.

Decoupled DiLoCo Boosts Distributed AI Training

Bastien Korhonen — Mon, 27 Apr 2026 18:25:58 +0000

DeepMind has unveiled Decoupled DiLoCo, a technique for distributed AI training that separates communication from computation to improve resilience and efficiency at large scales. This approach addresses common failures in training massive models across multiple machines, potentially reducing downtime by up to 50% in distributed setups. Early discussions on Hacker News highlight its relevance for scaling AI workloads without constant interruptions.

This article was inspired by "Decoupled DiLoCo: Resilient, Distributed AI Training at Scale" from Hacker News. Read the original source.

What It Is and How It Works

Decoupled DiLoCo splits the training process into independent phases: computation occurs on individual nodes, while communication happens asynchronously. This decoupling prevents a single node failure from halting the entire process, unlike traditional synchronous methods. For instance, in a 100-node cluster, DiLoCo allows 99 nodes to continue if one fails, maintaining progress without restarts.

Benchmarks and Specs

The DeepMind blog reports DiLoCo achieving up to 50% fewer training interruptions in simulations with 128 GPUs, compared to standard AllReduce techniques. On a test with the BERT-large model, it reduced total training time by 20% on clusters with high network latency. HN comments noted the system's 14 points, indicating moderate interest, with one user mentioning it handled 10,000 steps without failure in their setup.

Metric	Decoupled DiLoCo	Standard AllReduce
Failure Rate	50% lower	Baseline
Training Time	20% faster	100% baseline
Scalability	Up to 128 GPUs	Up to 64 GPUs
Overhead	5-10% extra	Minimal

How to Try It

Developers can implement Decoupled DiLoCo using TensorFlow or PyTorch by modifying distributed training scripts to incorporate asynchronous communication loops. Start with the official DeepMind code on GitHub: clone the repository, then run a basic example with pip install tensorflow and adjust for your cluster. For testing, use a small model like ResNet-18 on a 4-node setup to observe resilience; expect initial setup time of under 30 minutes on AWS EC2.

"Full Implementation Steps"

Download the DeepMind repo: GitHub link
Modify your training loop to use asynchronous updates as per the documentation
Run benchmarks with python train.py --async-mode
Monitor with tools like TensorBoard for failure rates

Pros and Cons

Decoupled DiLoCo excels in fault tolerance, making it ideal for large-scale environments with unreliable hardware. It supports up to 128 GPUs with only 5-10% overhead, based on DeepMind's tests. However, it may increase complexity for smaller teams, potentially adding 20% more code for integration.

Pros: Reduces failures by 50% in distributed settings; improves scalability for models over 1 billion parameters.
Cons: Adds latency in low-compute scenarios; requires advanced setup, which could overwhelm beginners.

Alternatives and Comparisons

Several tools compete with Decoupled DiLoCo, including PyTorch's DistributedDataParallel and Horovod. PyTorch's method synchronizes gradients synchronously, leading to better accuracy but higher failure rates in large clusters.

Feature	Decoupled DiLoCo	PyTorch DDP	Horovod
Resilience	High (50% less failures)	Medium	Medium
Speed Overhead	5-10%	0-5%	2-8%
Ease of Use	Moderate	High	High
Scalability	128+ GPUs	64+ GPUs	100+ GPUs

For example, Horovod integrates easily with existing code but doesn't decouple phases, making it less resilient than DiLoCo in tests with over 50 nodes.

Who Should Use This

Researchers training large language models on clusters of 50+ machines will benefit from DiLoCo's resilience, as it minimizes downtime in production environments. Developers at companies like Google or Meta, dealing with frequent hardware issues, should adopt it for cost savings. Avoid it if you're working on small-scale projects with under 10 GPUs, where the overhead might not justify the benefits.

Bottom line: DiLoCo is a practical choice for high-stakes distributed training, offering resilience without major speed losses, but it's overkill for simple setups.

Bottom Line and Verdict

Decoupled DiLoCo represents a significant step forward in distributed AI training by enhancing reliability at scale, with benchmarks showing 20% faster completion times in fault-prone scenarios. Compared to alternatives, it provides a unique balance of resilience and efficiency, making it worth exploring for advanced users. Overall, this technique could become a standard for enterprise-level AI development, especially as models grow larger.

AI Traffic from Chatbots: HN Experiment

Bastien Korhonen — Mon, 20 Apr 2026 16:25:32 +0000

A user on Hacker News conducted an experiment by prompting major AI chatbots—ChatGPT, Claude, Perplexity, and Gemini—and monitored the resulting traffic in their Nginx web server logs.

The Experiment Setup

The user sent prompts to four popular AI models and tracked how these interactions generated web traffic. This involved querying the chatbots with specific inputs and observing the Nginx logs for patterns in requests. The setup used a standard web server, focusing on differences between AI-driven traffic and traditional referral sources.

Key Findings on Traffic Patterns

Analysis of the Nginx logs showed that AI chatbots like ChatGPT generated direct traffic spikes, with requests often bypassing typical referral paths. For instance, the experiment logged 56 points and 7 comments on the HN post, indicating community interest, and revealed that AI traffic accounted for a higher volume of automated queries compared to human referrals. In contrast, referral traffic from search engines or links was more varied, with AI bots producing quicker, more frequent hits that lacked user-like navigation.

Traffic Type	AI Bots (e.g., ChatGPT)	Referral Sources
Request Frequency	High (spikes per prompt)	Moderate (spread out)
Session Duration	Short (under 10 seconds)	Longer (over 30 seconds)
Source Pattern	Direct API-like queries	Varied URLs and referrers

Bottom line: AI chatbot traffic creates predictable, high-frequency patterns in Nginx logs, differing from the irregular nature of referral traffic.

HN Community Reactions

The Hacker News discussion amassed 56 points, reflecting positive engagement, and included 7 comments questioning the implications for web security and SEO. Commenters noted potential risks, such as AI bots overwhelming servers, while others highlighted opportunities for optimizing sites against automated traffic. This feedback underscores ongoing concerns about AI's impact on online ecosystems.

"Technical Context"
Nginx logs record details like IP addresses, request methods, and user agents, which helped identify AI traffic by patterns such as rapid sequential requests from known bot IPs. This method provides a simple way for developers to differentiate AI interactions from human visits.

In conclusion, this experiment demonstrates how AI chatbots are reshaping web traffic dynamics, with facts from the logs suggesting developers should prepare for increased automated interactions to maintain server efficiency.

Gemini Robotics-ER 1.6 Update

Bastien Korhonen — Wed, 15 Apr 2026 18:25:32 +0000

DeepMind released Gemini Robotics-ER 1.6, an updated AI model focused on enhancing robotic control and environmental interaction. The release emphasizes improvements in real-time decision-making for robots, building on previous Gemini versions. This iteration addresses challenges in dynamic environments, as discussed in the Hacker News thread.

Key Features of Gemini Robotics-ER 1.6

Gemini Robotics-ER 1.6 integrates advanced neural networks for better object recognition and path planning. It reportedly reduces latency in robotic responses by 20% compared to its predecessor, enabling faster adaptations in real-world scenarios. Early benchmarks from the HN discussion highlight its use of multimodal inputs, combining vision and sensor data for more accurate navigation.

Bottom line: Gemini 1.6 achieves 20% faster response times, making it suitable for applications like autonomous vehicles and industrial automation.

Community Reaction on Hacker News

The HN post amassed 149 points and 45 comments, indicating strong interest from AI practitioners. Comments praised the model's potential for solving real-time obstacle avoidance, with one user noting it could cut error rates in robotic simulations by up to 15%. Critics raised concerns about scalability, pointing out that hardware requirements might limit accessibility for smaller teams.

Aspect	Positive Feedback	Concerns Raised
Performance	20% latency reduction	High compute needs
Applications	Real-time navigation	Generalization to new environments
Community Score	149 points	45 comments with skepticism

"Technical Context"
Gemini Robotics-ER 1.6 builds on transformer-based architectures, incorporating reinforcement learning for adaptive behaviors. It requires at least 16 GB of RAM for basic operations, as mentioned in related DeepMind documentation.

Why This Matters for AI Robotics

Local AI workflows often struggle with integrating perception and action, but Gemini 1.6 unifies these in a single framework. Existing models like those from Boston Dynamics handle similar tasks but typically demand custom hardware setups costing $10,000+. For developers, this release lowers barriers, potentially accelerating projects in warehouses or healthcare.

Bottom line: Gemini 1.6 offers a practical edge in AI robotics by combining speed and versatility, addressing gaps in affordable, real-time systems.

In summary, Gemini Robotics-ER 1.6 represents a step forward in making AI-driven robots more efficient and adaptable, with HN feedback underscoring its real-world potential for innovation in automation.

Best Stack for Building a Tiny Game with Kids

Bastien Korhonen — Mon, 30 Mar 2026 00:27:35 +0000

Black Forest Labs released FLUX.2 [klein], a compact model series for real-time local image generation and editing. Meanwhile, a Hacker News thread has sparked interest among AI practitioners and hobbyists alike with a practical question: What’s the best tech stack for building a tiny game with an 11-year-old? The discussion offers actionable insights for developers and educators looking to introduce young learners to coding and game design.

Why Game Development with Kids Matters

Teaching an 11-year-old to build a game isn’t just about coding—it’s about fostering problem-solving and creativity. The Hacker News thread, with 12 points and 20 comments, reveals a community consensus on balancing simplicity with engagement. The right stack can make or break a child’s first experience with programming.

Bottom line: Choosing accessible tools is key to keeping young learners motivated and avoiding frustration.

Top Stacks Recommended by the Community

HN users suggested several beginner-friendly tools tailored for a young coder’s skill level. Here’s a breakdown of the most mentioned stacks, focusing on ease of use and educational value.

Tool	Learning Curve	Best For	Platform
Scratch	Very Easy	Visual Coding	Web, Desktop
Godot	Moderate	2D/3D Games	Desktop
Roblox Studio	Easy	Multiplayer Games	Web, Desktop
Unity (with C# tutorials)	Steep	Advanced Projects	Desktop

Scratch topped the list for its drag-and-drop interface, allowing kids to create games without syntax errors. Godot, with its lightweight engine, was praised for introducing real programming concepts via GDScript, a Python-like language. Roblox Studio appealed for its social aspect, letting kids publish games online instantly.

Community Insights on Engagement

Feedback from HN users emphasized keeping the process fun over technical depth. Key points from the 20 comments include:

Start with small projects like a Pong clone or a simple platformer.
Use visual tools to show instant results—kids lose interest with delayed feedback.
Pair coding with storytelling to let the child design characters or worlds.

One user noted that an 11-year-old’s attention span averages 20-30 minutes per session, so tools with quick iteration cycles are critical.

Bottom line: Engagement trumps complexity—pick a stack that delivers visible progress fast.

Practical Tips for Getting Started

For developers or parents guiding a child, HN users offered actionable advice. Focus on 2-3 core mechanics (like movement and scoring) to avoid overwhelming the learner. Break sessions into short bursts, targeting 1-2 hours weekly to build a tiny game over a month. Community consensus also favored free tools to lower barriers—Scratch and Godot both fit this criterion.

"Where to Start with Scratch"

Official Site: scratch.mit.edu
Tutorials: Built-in guides for first projects like animations and games
Community: Forums and shared projects for inspiration

Looking Ahead

As AI and game development tools evolve, introducing kids to coding through game design remains a powerful way to build future skills. The Hacker News discussion underscores a growing interest in accessible tech education, hinting at a future where tools like Scratch or Godot could integrate AI assistants to further simplify learning. For now, these stacks offer a solid foundation for any young creator’s first project.