DEV Community: Li DevTools

The AI Manga Consistency Checklist: 5 Lessons From 100+ Pages

Li DevTools — Thu, 11 Jun 2026 12:44:15 +0000

If you've ever tried making a multi-page manga with AI, you know the pain: your blue-haired protagonist in Page 1 looks nothing like the same character on Page 3. Hair changes color, outfit shifts, face structure mutates. It's the #1 frustration I hear from AI manga creators.

After producing over 100 pages of AI manga, here are 5 consistency lessons that actually matter — and the workflow that made the difference.

1. The Problem Is Context, Not Models

Most people blame the AI model for inconsistency. But here's what's really happening: each image generation is a fresh inference. The model has zero memory of what it generated 5 minutes ago.

Think of it like asking 10 different artists to draw the same character — each will interpret "blue-haired girl" differently. AI models are the same: they generate from a probability distribution, not from memory.

The fix: You need a system that explicitly anchors character appearance across generations, not a better prompt.

2. Character Reference Sheets Are Non-Negotiable

Before generating a single manga panel, create a detailed character reference sheet showing:

Front view, side view, back view
Exact color hex codes for hair, eyes, outfit
Distinguishing features (scar, accessory, pattern)
Multiple expressions on the same sheet

This sheet becomes your "ground truth." Every subsequent generation references it.

Pro tip: Generate the reference sheet first, then use it as an image input for subsequent panels. This gives the AI a visual anchor rather than just text descriptions.

3. The Sliding Window Technique

For a 20-page manga, don't just use the reference sheet for every page. Instead, use a sliding window:

Page 1-3: Reference sheet + previous panel
Page 4-6: Reference sheet + Panel 3 output
Page 7-9: Reference sheet + Panel 6 output

Each panel references the reference sheet (for appearance anchoring) AND the immediately preceding panel (for temporal continuity). This prevents "context drift" where characters gradually diverge.

4. Prompt Engineering for Consistency

Generic prompts produce generic results. For manga consistency, your prompts need:

Character lock: Always start with the exact same character description

[CHARACTER] 17-year-old girl, silver-white hair to shoulders,
emerald green eyes, small star-shaped earring on left ear,
white school uniform with navy collar

Scene description: What's happening in THIS panel

[SCENE] Standing at classroom window, looking outside,
afternoon sunlight, wind blowing hair

Style anchor: Consistent art style across all panels

[STYLE] Clean line art, flat cel-shading, soft pastel colors,
manga panel composition

Negative constraints: What to avoid

[FORBIDDEN] No background scenery variation, no outfit changes,
no hair color shifts, no age changes

5. The Tool That Changed My Workflow

I tried building my own consistency pipeline with ComfyUI nodes, ControlNet, and IP-Adapter. It worked, but required constant tweaking and technical knowledge.

Then I found pixiaoli.cn — a platform specifically designed for AI manga creation with character consistency built in. Instead of managing reference images and prompt templates manually, the tool remembers your characters across sessions.

The difference was immediate: I went from spending 30 minutes per panel on consistency fixes to spending that time on storytelling instead.

What makes it different from generic AI art tools:

Character memory: upload a character once, use it across all panels
Panel-by-panel generation with consistency checking
Manga-specific layout tools (panel borders, speech bubbles)
Export as printable PDF or web-optimized format

The Reality Check

AI manga consistency isn't perfect yet. You'll still get:

Occasional face shape variations
Expression mismatches between panels
Detail drift on accessories

But with the right workflow — reference sheets + sliding window + consistency tools — you can get 90%+ consistency, which is more than good enough for web publishing.

Quick Start Checklist

[ ] Create detailed character reference sheets before starting
[ ] Use a sliding window approach (reference + previous panel)
[ ] Lock character descriptions in prompts
[ ] Generate panels in order, not random sequence
[ ] Review and regenerate inconsistent panels immediately
[ ] Use a manga-specific tool like pixiaoli.cn for the pipeline

If you're building AI manga and struggling with character consistency, try pixiaoli.cn — it's free to start and specifically built for this workflow.

Have you found other techniques that work? I'd love to hear what's working for you in the comments.

Your Browser Is the Best Runtime: Why I Stopped Building Servers for Developer Tools

Li DevTools — Thu, 11 Jun 2026 12:16:41 +0000

Every year, thousands of developer tools launch with the same architecture: a frontend, a backend, a database, and a hosting bill. But what if the best runtime for developer tools... is the browser itself?

The Problem with Server-Side Tools

I've built and used hundreds of online developer tools — JSON formatters, CSV converters, regex testers, password generators. They all share the same pattern:

You paste your data into a web form
It gets sent to a server
The server processes it
Results come back

For a JSON formatter, this means your API keys, database credentials, and sensitive data travel across the internet just to add some indentation. For a CSV converter, your customer data hits an unknown server before becoming a spreadsheet.

Why do we accept this?

The Client-Side Alternative

When I built tools.pixiaoli.cn, I asked a simple question: what if nothing ever leaves the browser?

The result is 33+ developer tools that run entirely in JavaScript. No server. No API calls. No data collection. Your data stays in your browser's memory and disappears when you close the tab.

Here's what this means in practice:

JSON Formatter — paste JSON, get formatted output instantly. Your API keys never touch a network.
CSV to JSON Converter — transform your data locally. Customer PII stays on your machine.
WeChat Markdown Editor — write and preview Markdown formatted for WeChat articles. No cloud dependency.
Password Generator — generate secure passwords client-side. No one else sees them.
Base64 Encoder/Decoder — encode and decode without sending data to external services.

The Technical Architecture

Building client-only tools has interesting constraints:

// Every tool follows this pattern:
function processData(input) {
  // All computation happens here
  // No fetch(), no XMLHttpRequest, no WebSocket
  const result = transform(input);
  return result;
}

No fetch() calls. No XMLHttpRequest. No WebSocket. Every function is pure — input goes in, output comes out, and nothing in between leaves the browser.

The Benefits

Privacy by design. Not "we promise not to look at your data" — it's architecturally impossible for us to see it. There's no server to send it to.

Speed. No network latency. The JSON formatter processes 10MB files instantly because it's just string manipulation in your browser.

Offline capable. Once loaded, every tool works without an internet connection. Perfect for flights, secure environments, or just spotty WiFi.

Zero infrastructure costs. No servers to maintain, no databases to scale, no DDoS protection to buy. The CDN serves static files; your browser does the rest.

The Trade-offs

I won't pretend client-only is perfect:

No persistence — your data doesn't survive a page refresh (by design)
No collaboration — you can't share results via a URL
Browser limits — very large files (>100MB) may struggle depending on your device
No server-side processing — some tasks genuinely need a server (like image compression with native codecs)

For developer tools, these trade-offs are almost always worth it. The tools I use daily — JSON formatting, CSV conversion, text transformation — don't need any of those server features.

Why This Matters in 2026

With increasing concerns about data privacy, supply chain attacks (like the recent npm package compromises), and the general trend of "everything is a SaaS subscription," there's value in tools that are:

Transparent — you can view the source and verify nothing shady happens
Independent — no company can shut down your JSON formatter
Free — no subscription, no freemium, no "please upgrade to Pro"

Try It

If you work with JSON, CSV, or Markdown regularly, give tools.pixiaoli.cn a shot. 33+ tools, all free, all client-side.

The best developer tool is the one that gets out of your way and lets you focus on your actual work. Sometimes that means building something so simple it doesn't even need a server.

What developer tools do you use daily that you wish were client-side? I'm always looking for ideas for new tools to build.

I Created a 10-Page AI Manga Chapter in 3 Hours — Here's Exactly How

Li DevTools — Thu, 11 Jun 2026 11:39:52 +0000

I've been experimenting with AI-assisted manga creation for the past few months, and the biggest challenge has always been character consistency. Every panel, every angle — the character looks slightly different. Different hair color, different face shape, different outfit details.

Last weekend, I challenged myself: create a complete 10-page manga chapter in one sitting using AI. Here's what I learned.

The Problem: AI Forgets Your Characters

If you've tried making AI comics, you know the pain. You generate a beautiful panel with a silver-haired swordsman, and the next panel gives you a completely different person. Even with reference images, most AI tools treat each generation independently.

This kills any story-driven work. You can't have a narrative if your protagonist changes appearance every page.

My Workflow: Reference Anchoring

The breakthrough came when I started using pixiaoli.cn — a tool specifically designed for AI manga with character consistency. Here's the core idea:

Design your character once — full reference sheet with front, side, and back views
Upload as anchor — the tool uses this as a consistency reference
Generate panels one by one — each new panel references the anchor AND the previous panel

This "sliding window" approach means every panel references both the original design and the immediately preceding panel. The result? Characters that actually look like themselves throughout the story.

The 3-Hour Sprint

Here's how my session went:

Hour 1: Setup (30 min)

Wrote a brief story outline (5 scenes, ~20 panels)
Designed 3 main characters using the reference sheet workflow
Created a simple color palette for mood consistency

Hour 1-2: Generation (90 min)

Generated panels in order, one at a time
Each panel took about 3-4 minutes (prompt refinement + generation)
Key tip: write detailed panel descriptions BEFORE generating
Used the reference sheet as anchor for every panel

Hour 3: Polish (60 min)

Added speech bubbles and text
Adjusted panel layouts
Minor touch-ups on inconsistent details

What Surprised Me

The consistency actually holds up. Not perfectly — maybe 85-90% match across panels. But that's a huge improvement over the 20-30% consistency I was getting before.

Speed is real. 10 pages in 3 hours is faster than my traditional drawing pace by about 5x.

The story matters more now. When you're not fighting consistency, you can focus on pacing, composition, and narrative flow.

Tools I Used

pixiaoli.cn — character consistency engine (the core of the workflow)
Gemini — for initial character design discussions
Canva — for speech bubbles and text layout
Photopea — for final panel composition

Tips for Your First Manga Sprint

Start with character design, not story. Get your characters looking right first.
Keep it short. 5-10 pages is perfect for a first attempt.
Write panel-by-panel descriptions. Don't improvise during generation.
Save your reference sheets. You'll use them for every panel.
Accept imperfection. 85% consistency is workable — you can fix the rest manually.

The Bigger Picture

AI manga creation isn't replacing traditional art — it's enabling a new workflow. Creators who can't draw (or don't have time) can now tell visual stories. And for experienced artists, it's a rapid prototyping tool.

The character consistency problem was the biggest blocker. With tools like pixiaoli.cn solving it, I think we'll see a lot more AI-assisted comics in 2026.

Have you tried creating AI comics? What's been your biggest challenge? I'd love to hear about your workflows in the comments.

Free to try: pixiaoli.cn

Building 33+ Developer Tools That Never See Your Data

Li DevTools — Thu, 11 Jun 2026 10:56:15 +0000

Last month I released tools.pixiaoli.cn -- a collection of 33+ developer utilities that run entirely in your browser. No servers, no accounts, no data leaving your machine.\n\nHere's what I learned building it.\n\n## The Core Principle: Zero Network Requests for User Data\n\nEvery tool on the site follows one rule: your data never touches a server.\n\nThis sounds simple, but it changes everything about how you architect the tools:\n\n

\nTraditional approach:\nBrowser -> Send data to server -> Server processes -> Return result\n\nClient-side approach:\nBrowser -> Process in browser -> Display result (data never leaves)\n

\n\nThe second approach means:\n- No backend costs -- zero server bills\n- No privacy concerns -- data stays local\n- Instant results -- no network latency\n- Works offline -- once loaded, no internet needed\n\n## The Tool List (Yes, All 33+)\n\nHere's what's included:\n\n### Formatters and Converters\n- JSON Formatter/Validator -- with syntax highlighting and error pinpointing\n- CSV to JSON Converter -- handles quoted fields, escaped commas\n- JSON to CSV Converter -- flatten nested objects automatically\n- XML to JSON Converter -- bidirectional conversion\n- YAML to JSON Converter -- with error line highlighting\n\n### Text and Writing\n- WeChat Markdown Editor -- the most popular tool, converts Markdown to WeChat-compatible rich text with one click\n- Text Difference Checker -- side-by-side diff with highlighted changes\n- Word/Character Counter -- with reading time estimate\n- Case Converter -- camelCase, snake_case, PascalCase, kebab-case\n\n### Image Tools\n- Image Format Converter -- PNG, JPG, WebP, BMP\n- Image Compressor -- quality slider with preview\n- Image to Base64 -- for embedding in CSS/HTML\n- QR Code Generator -- customizable colors and style\n\n### Encoding and Security\n- Base64 Encoder/Decoder -- text and file\n- URL Encoder/Decoder -- with component encoding options\n- HTML Entity Encoder/Decoder -- for safe HTML output\n- Hash Generator -- MD5, SHA-1, SHA-256, SHA-512\n\n### Developer Utilities\n- Regex Tester -- with match highlighting and group capture\n- Cron Expression Parser -- shows next 5 execution times\n- UUID Generator -- v1, v4, and custom format\n- Color Picker -- HEX, RGB, HSL with palette generation\n- Timestamp Converter -- Unix to human-readable, any timezone\n\n## Architecture: How to Build This Without a Server\n\n### The Simple Pattern\n\nEach tool is a self-contained HTML file with embedded CSS and JavaScript:\n\n

html\n<!DOCTYPE html>\n<html>\n<head><title>JSON Formatter</title></head>\n<body>\n <textarea id="input"></textarea>\n <button id="format">Format</button>\n <pre id="output"></pre>\n <script>\n document.getElementById('format').addEventListener('click', () => {\n const input = document.getElementById('input').value;\n const output = JSON.stringify(JSON.parse(input), null, 2);\n document.getElementById('output').textContent = output;\n });\n </script>\n</body>\n</html>\n

\n\nNo build tools. No npm. No webpack. Just HTML, CSS, and vanilla JavaScript.\n\n### The Hard Part: Edge Cases\n\nThe actual challenge is not architecture -- it is handling every edge case your users will hit:\n\n1. JSON Formatter: Handle trailing commas, single quotes, comments in "JSON-like" input\n2. CSV Converter: Deal with newlines inside quoted fields, different delimiters (comma, tab, semicolon)\n3. Image Converter: Browser limitations on format support, memory limits for large images\n4. Markdown Editor: WeChat's rich text has specific restrictions (no style tags, limited HTML)\n\n### Performance at Scale\n\nWith 33+ tools on one site, performance matters:\n\n- Lazy loading: Tools load only when clicked, not on page load\n- No frameworks: React/Vue add 40KB+ for a simple formatter -- unnecessary\n- Minimal DOM manipulation: Direct textContent and classList instead of innerHTML\n- Web Workers for heavy computation: Hash generation and image processing run off the main thread\n\n## What Users Actually Care About\n\nAfter launching, I tracked which tools got the most use:\n\n1. WeChat Markdown Editor (40% of traffic) -- Chinese developers writing WeChat articles\n2. JSON Formatter (25%) -- the universal developer need\n3. Image Format Converter (15%) -- designers and developers converting assets\n4. CSV/JSON Converters (10%) -- data processing workflows\n5. Everything else (10%) -- the long tail\n\nThe surprise? The WeChat Markdown Editor dominates. It solves a very specific pain point: WeChat's article editor does not support Markdown, but everyone writes in Markdown. Our tool converts Markdown to WeChat-compatible HTML with one click.\n\n## Privacy as a Feature, Not a Buzzword\n\nMost "online formatters" send your code/data to their servers. You can verify this yourself:\n\n1. Open any online JSON formatter\n2. Open browser DevTools, Network tab\n3. Paste some JSON and click Format\n4. Watch the POST request fly off to their server\n\nWith tools.pixiaoli.cn, there are zero XHR/fetch requests when you use a tool. Everything happens in the browser's JavaScript engine.\n\nThis matters most for:\n- API keys in config files\n- Personal data in CSV files\n- Proprietary code being formatted\n- Sensitive text being encoded\n\n## Try It\n\nThe site is at tools.pixiaoli.cn. No signup, no ads, no tracking. Just tools.\n\nIf you are a developer who has ever hesitated before pasting code into a random online formatter -- this is for you.\n\n---\n\n*Built with vanilla HTML/CSS/JS. No frameworks, no servers, no data collection. Open source contributions welcome.*

Why Your AI Manga Characters Look Different in Every Panel (And How to Fix It)

Li DevTools — Thu, 11 Jun 2026 10:19:12 +0000

Ever tried creating a manga or comic with AI and noticed your main character has blue eyes in panel 1, brown eyes in panel 2, and somehow a different hairstyle in panel 3?

Character consistency is the #1 frustration for AI comic creators. You spend hours crafting the perfect character design, only to watch it morph across panels like a funhouse mirror.

The Core Problem

AI image generators treat each prompt as independent. They don't "remember" your character from the previous image. So even with the same prompt, you get:

Different facial features
Inconsistent clothing
Varying hair color/style
Shifting body proportions

This kills any narrative flow. Readers can't follow a story when the protagonist keeps changing.

What Actually Works

After testing dozens of approaches, I found that the key is character anchoring — giving the AI a fixed reference that persists across all generations.

pixiaoli.cn solves this by maintaining character memory across panels. You define your character once, and every subsequent generation references that definition.

Here's my workflow:

Design the character — Create a detailed reference with specific features (hair color, eye shape, outfit details)
Lock the reference — Pin the character design so it doesn't drift
Generate panels — Each new panel references the locked design automatically
Adjust as needed — Fine-tune individual panels while keeping consistency

Results

The difference is dramatic. Before using character anchoring, my 10-page comic had a character who looked like 5 different people. After switching to a consistent reference system, every panel showed the same character — same eyes, same hair, same outfit details.

This isn't just about aesthetics. Consistency is what separates a comic from a collection of random AI images. Readers need to recognize characters instantly to follow the story.

Tips for Better Consistency

Be specific in your initial design: "silver-white hair, crimson eyes, black leather jacket" beats "cool anime character"
Use reference images: Upload your character design as a reference for each new panel
Limit style variations: Stick to one art style across panels
Check early: Generate a test panel before committing to 20+ pages

Try It

If you've been struggling with AI character consistency for comics, manga, or webtoons, give pixiaoli.cn a try. It's free to start and specifically built for this use case.

What's your biggest challenge with AI-generated comics? I'd love to hear what approaches others are using.

33+ Free Developer Tools That Never Send Your Data

Li DevTools — Thu, 11 Jun 2026 09:36:26 +0000

The Problem with Most Online Formatters

You know the drill. You paste some JSON into a random online formatter, or convert a CSV to Markdown, or format a WeChat article. The tool works fine, but have you ever stopped to think about what happens to your data?

Most "free" online tools send your content to their servers. Some store it. Some log it. Some sell aggregated data. You have no idea where your sensitive JSON payload, proprietary CSV data, or internal documentation ends up.

The Client-Side Alternative

I built tools.pixiaoli.cn — a collection of 33+ developer utilities that run entirely in your browser. No server uploads. No data collection. Your content never leaves your machine.

What's Inside

Here's a taste of what's available:

JSON Formatter & Validator — Format, minify, validate, and tree-view JSON instantly
CSV Converter — Convert between CSV, JSON, and Markdown tables
WeChat Markdown Editor — Write Markdown and preview it exactly as it appears in WeChat articles
Base64 Encoder/Decoder — With file upload support
URL Encoder/Decoder — For query parameters and path segments
Hash Generator — MD5, SHA-1, SHA-256, SHA-512
Color Converter — Between HEX, RGB, HSL, and named colors
Regex Tester — Live pattern matching with highlighted results
Diff Viewer — Side-by-side text comparison
Code Formatter — JavaScript, CSS, HTML, SQL, and more
UUID Generator — v4 UUIDs for APIs and databases
QR Code Generator — Customizable with logo support
Markdown Preview — Live split-pane editor
Image Format Converter — PNG, WebP, JPEG, GIF, BMP, AVIF
Text Case Converter — camelCase, snake_case, kebab-case, and more
Lorem Ipsum Generator — Customizable paragraph count and word limits
HTML Minifier — Remove whitespace and comments
CSS Minifier — Compress stylesheets
JavaScript Minifier — Obfuscate and compress JS
XML Formatter — Pretty-print XML documents
YAML Formatter — Validate and format YAML
HTML to Markdown — Convert rich HTML to clean Markdown
Markdown to HTML — Render Markdown to HTML with live preview
JWT Decoder — Inspect JSON Web Token payloads
Cron Expression Parser — Visualize cron schedules
Color Palette Generator — From any base color
CSS Grid Generator — Visual grid layout builder
CSS Flexbox Generator — Interactive flexbox playground
SVG Optimizer — Compress and clean SVG files
HTML Entity Encoder/Decoder — Encode special characters
Markdown Table Generator — Visual table builder
Privacy Policy Generator — GDPR-compliant templates

How It Works

Every tool runs client-side using JavaScript. The HTML, CSS, and JS are bundled together — when you open a tool, everything loads into your browser's memory. Your data is processed locally and displayed on screen.

No API calls. No analytics tracking on your content. No hidden uploads.

For example, the JSON formatter uses and directly in your browser. The CSV converter uses the browser's built-in parsing. The image converter uses the Canvas API. Nothing touches a server.

Why This Matters for Developers

As developers, we handle sensitive data daily:

API payloads with authentication tokens
Database exports with production data
Configuration files with secrets
Customer data in CSV/Excel format

Using a random online tool with these is a security risk. With client-side tools, you get the same convenience without the privacy concern.

Tech Stack

The site is built with:

Vanilla JavaScript — No frameworks, no dependencies, fast load times
Modern CSS — Responsive design, dark mode support
Progressive Web App — Works offline after first load
Zero server dependencies — Hosted on a simple static file server

The entire site is under 500KB. Tools load instantly because there's nothing to fetch from a backend.

Try It

tools.pixiaoli.cn — 33+ free developer tools, 100% client-side, your data never leaves your browser.

No registration required. No ads on content. Just tools that work.

What client-side tools do you use in your workflow? I'm always looking to add more utilities to the collection.

I Built 33+ Free Developer Tools That Run Entirely in Your Browser

Li DevTools — Thu, 11 Jun 2026 08:59:35 +0000

I got tired of using random online formatters that send my data to unknown servers. So I built a collection of 33+ developer tools that run entirely in your browser — no server, no data collection.

What's in there?

JSON Formatter & Validator — with syntax highlighting and error detection
CSV to JSON / JSON to CSV — bidirectional converter
WeChat Markdown Editor — specifically formatted for WeChat articles
Base64 Encoder/Decoder — for quick encoding tasks
URL Encoder/Decoder — percent-encoding made easy
Color Picker & Converter — HEX, RGB, HSL all in one
Regex Tester — test patterns with live matching
JWT Decoder — inspect tokens without sending them anywhere
Timestamp Converter — Unix ↔ human-readable
... and 23+ more tools

Why client-side?

The key principle: your data never leaves your browser. Everything runs in JavaScript locally. No API calls, no analytics tracking your inputs, no "we might use your data for improvement."

For developers working with sensitive data (API keys, customer data, proprietary configs), this matters. You can format, convert, and validate without worrying about where your data goes.

Tech stack

Pure HTML + CSS + vanilla JavaScript. No frameworks, no build tools, no dependencies. Each tool is a standalone page that loads instantly.

The whole site is open source and hosted on a simple static server.

Try it out

🔗 tools.pixiaoli.cn

It's completely free, no sign-up required. Just open and use.

If you find it useful, I'd love to hear what tools you'd want added next. I'm actively building more based on what the developer community needs.

What free developer tools do you use daily? I'm always looking for ideas to add to the collection.

How I Create AI Manga Panels with Consistent Characters — My Complete Workflow

Li DevTools — Thu, 11 Jun 2026 08:20:59 +0000

I've been experimenting with AI for manga creation for months, and the single biggest headache has been character consistency. You know the problem: you generate a beautiful character in panel 1, then in panel 2 they look like a completely different person.

After a lot of trial and error, I've settled on a workflow that actually works. Here's what I've learned.

The Core Problem

AI image generators are great at creating individual images. They're terrible at maintaining character identity across a sequence. Every generation is essentially a fresh start — the model has no memory of what your character looked like 5 seconds ago.

This matters because manga and comics are sequential art. If your protagonist has blue hair in page 1 and brown hair in page 3, readers disengage. It breaks immersion instantly.

What Actually Works

1. Character Reference Sheets (The Foundation)

Before generating any panels, create a detailed character reference sheet. This should include:

Front view — face, outfit, proportions
Side view — profile silhouette
Back view — hair details, outfit from behind
Key accessories — the things that make them recognizable

The reference sheet becomes your anchor. Every panel generation should reference it.

2. Detailed Text Descriptions (Backup Plan)

Alongside visual references, write a precise text description of each character:

Character: Hana
- Age: 17, female
- Hair: Long, silver-blue, straight with slight wave at ends
- Eyes: Large, amber/gold, slightly downturned
- Outfit: School uniform — white blouse, navy blazer, red ribbon
- Distinguishing mark: Small star-shaped earring on left ear
- Expression default: Gentle, slightly worried

This text serves as a fallback when visual references aren't enough. Be specific about colors, proportions, and distinguishing features.

3. The Sliding Window Technique

For multi-page stories, I use a "sliding window" approach:

Page 1: Generate from character reference sheet only
Page 2: Reference character sheet + Page 1 output
Page 3: Reference character sheet + Page 2 output
And so on...

Each page anchors to both the original reference AND the immediately preceding page. This prevents "context drift" where characters gradually change appearance.

4. Consistent Style Keywords

Every prompt should include the same style anchors:

[manga style, clean line art, soft cel shading, consistent character design]

Mixing styles between panels is the fastest way to break consistency. Pick a style and commit to it.

My Tool Setup

I've been using pixiaoli.cn as my primary tool for this workflow. It's designed specifically for AI manga creation with character consistency built in. The key features that matter:

Character memory — it remembers your characters between generations
Panel-to-panel consistency — characters maintain appearance across pages
Manga-specific formatting — panel layouts, speech bubbles, sound effects

For quick text formatting and script writing, I also use tools.pixiaoli.cn — it has a WeChat-style Markdown editor that's great for writing comic scripts on the go.

Common Pitfalls

The "Same Face" Trap

Generating the same character from the exact same angle every time makes your comic feel static. Vary camera angles, but keep the character's core features consistent.

Over-Reliance on Reference Images

Visual references help, but they're not magic. You still need to write detailed text descriptions. The best results come from combining both.

Ignoring Background Continuity

Character consistency is obvious, but background consistency matters too. If your character is in a classroom in panel 1, the classroom should look similar in panel 2.

The Bigger Picture

AI manga creation is still early. The tools are getting better fast — character consistency was nearly impossible a year ago, and now it's manageable with the right workflow.

The key insight is that consistency is a process, not a feature. No single tool or technique solves it completely. It requires deliberate planning, reference management, and iterative refinement.

If you're experimenting with AI comics, start with character reference sheets and build from there. The technology will catch up to your ambition.

What's your experience with AI character consistency? I'd love to hear what workflows work for you.

33+ Free Developer Tools That Run Entirely in Your Browser

Li DevTools — Thu, 11 Jun 2026 07:24:52 +0000

33+ Free Developer Tools That Run Entirely in Your Browser

We've all been there: you need to quickly format some JSON, convert a CSV, or edit a Markdown file, and you reach for one of those "free online tools" websites. But have you ever stopped to think about where your data goes when you paste it into those textareas?

Most online formatters and converters send your data to their servers. That JSON you just pasted? It might be sitting on some server you know nothing about. Your CSV with customer data? Same thing.

The Problem with Most Online Tools

Data privacy: Your code, config files, and data get uploaded to unknown servers
Ads and tracking: Most free tools are ad-supported with extensive tracking
Limited functionality: You often need 5 different sites for 5 different tasks
No offline support: What happens when your internet is down?

What If There Was a Better Way?

I found tools.pixiaoli.cn — a collection of 33+ developer tools that run 100% client-side. Your data never leaves your browser. Period.

Here's what's included:

🔧 Text & Code Tools

JSON Formatter & Validator — Pretty print, minify, and validate JSON
JSON to CSV Converter — Transform JSON arrays into clean CSV files
Base64 Encoder/Decoder — Quick encoding for APIs and data URIs
URL Encoder/Decoder — Handle URL parameters without fuss
Regex Tester — Test your patterns with real-time matching

📝 Content Tools

WeChat Markdown Editor — Write beautifully formatted WeChat articles
Markdown Preview — Live preview as you type
HTML to Markdown — Convert web content to clean Markdown

🎨 Visual Tools

Color Picker — Grab colors from anywhere, convert between formats
Image Format Converter — PNG, JPG, WebP, and more
Favicon Generator — Create favicons from any image

📊 Data Tools

CSV Viewer & Editor — Browse and edit CSV files in a spreadsheet-like UI
XML Formatter — Pretty print and validate XML
YAML Converter — Convert between YAML, JSON, and other formats

Why Client-Side Matters

When a tool runs in your browser, it means:

Your data stays on your machine — No uploads, no servers, no risk
Works offline — Once loaded, most tools work without internet
Fast — No server round-trips, instant results
Free forever — No premium tiers or usage limits

Try It Out

Head over to tools.pixiaoli.cn and see for yourself. The WeChat Markdown Editor alone is worth the visit if you create content for WeChat.

The best part? It's completely free, no registration required, and your data never touches a server.

What developer tools do you use regularly? Have you ever thought about where your data goes when you use online formatters?

Tags: #webdev #javascript #developer #tools #productivity #privacy

Why I Stopped Using Random Online Formatters (and What I Use Instead)

Li DevTools — Thu, 11 Jun 2026 06:33:43 +0000

Every developer has been there — you have a messy JSON blob, a CSV that needs converting, or a Markdown file that needs formatting for WeChat. So you Google "JSON formatter," click the first result, paste your data... and wonder: where did my data just go?

The Problem with Most Online Tools

Most free online formatters and converters send your data to their servers. You're pasting:

API responses with authentication tokens
CSV exports with customer data
Configuration files with secrets

Into a black box. You have no idea where that data goes, who sees it, or how long it's stored.

The Client-Side Alternative

What if every tool ran entirely in your browser? No server uploads, no data leaving your machine, no privacy concerns.

That's exactly what tools.pixiaoli.cn does — 33+ developer tools, all running client-side:

JSON Formatter & Validator — format, validate, and minify JSON without any server round-trip
CSV Converter — convert between CSV, JSON, and other formats entirely in-browser
WeChat Markdown Editor — format Markdown for WeChat articles with live preview
Text Tools — word count, case conversion, diff checker
Image Tools — resize, compress, format conversion

Why Client-Side Matters

Privacy — your data never leaves your browser
Speed — no network latency, instant results
Offline — works without internet (after first load)
Trust — open source, auditable code

When to Use What

Use Case	Client-Side Tool	Traditional Tool
Quick JSON format	Browser-based	Overkill
Sensitive data	Always safe	Check privacy policy
Large files (100MB+)	Browser limits	Desktop app
Team collaboration	Solo use	Shared tools

The Bottom Line

For 90% of quick formatting tasks, client-side tools are faster, safer, and simpler. The next time you need to format some JSON or convert a CSV, give tools.pixiaoli.cn a try — your data stays on your machine.

What tools do you use for quick formatting tasks? I'm always looking for recommendations.