How We Built a Human-in-the-Loop Pipeline for AI-Generated Coloring Pages

Derek Vance — Mon, 14 Sep 2026 08:26:42 +0000

EarlyHue is a free library of printable coloring pages for preschoolers, ages 3 to 5. Every page is a print-ready US Letter PDF, there is no account or email wall, and the library spans animals, shapes, numbers, alphabet, colors, weather, vehicles, dinosaurs, and seasonal themes.

We are a small team, so we use an AI image model to generate artwork at a scale we could never draw by hand. But the audience is a four-year-old with a crayon, and the pages sit in a children's education category. That combination means we cannot "just generate and publish." A stray detail, an inconsistent line weight, a garbled shape, or an image with unclear rights is a real problem when the reader is a preschooler and the buyer is a parent or teacher.

This is how we built a pipeline that lets AI do the heavy lifting while keeping a human accountable for every page that ships.

The problem with "just generate it"

Naive AI generation fails for a children's product in a few predictable ways:

Inconsistent difficulty. One image comes back with bold, simple shapes; the next has tiny details a three-year-old cannot color inside.
Silent defects. Occasionally a generation produces a malformed limb, a merged shape, or stray text-like marks that look like garbled letters.
Style drift. Across hundreds of pages, the "house style" (thick outlines, large open areas) drifts unless something enforces it.
Rights ambiguity. For a free public library, we need to know the origin and usage rights of every asset, not assume them.

None of these are acceptable when the page is going to a classroom. So we treat generation as the start of the pipeline, not the end.

Two gates, not one

The core design decision is simple: an illustration only becomes a public printable after it passes two independent gates.

Automated screening catches objective defects before a human spends time on it.
Mandatory human review makes a person accountable for age suitability, quality, originality, and rights.

We publish only what clears both. We would rather release fewer pages than skip a review, and the codebase is structured so that skipping is not the easy path.

Gate 0: structured briefs and recorded provenance

Every illustration starts as a structured brief, not a one-line prompt. The brief describes the subject, the composition, and the style constraints for young children: bold outlines, simple shapes, no tiny details. An AI image model (we use Seedream) generates candidate artwork from that brief.

Critically, we record the origin of every candidate. Each published illustration keeps:

the prompt and generation details,
a reference to the source asset file,
a SHA-256 hash of the source artwork.

The hash gives us content-addressable provenance. If a source file ever changes, the hash changes, and we know the published record no longer matches the asset it claims to describe. It makes audits and lineage checks cheap and deterministic instead of archaeological.

Gate 1: automated screening

Before any person looks at a candidate, it goes through automated screening. The checks look at line quality, composition, and consistency with the brief. Candidates that fail are rejected or regenerated rather than pushed forward.

One check worth calling out is a text-semantics pass. Coloring pages should be pure line art, so we run OCR over the candidate and flag anything that resolves to stray or garbled text. It is a surprisingly effective proxy for "something went wrong in generation," because malformed shapes often produce text-like artifacts. (We run this locally with Apple's Vision framework on macOS; the interesting part is not the tool but that a pure-line-art page should have no readable text, so any hit is a signal.)

Automated screening does not decide what ships. It decides what is worth a human's attention.

Gate 2: mandatory human review

No artwork becomes a public printable without human approval. A reviewer confirms four things:

Age suitability for the 3 to 5 range,
Originality and rights,
Visual quality (clean lines, correct shapes, no defects),
Consistency with EarlyHue's style.

The approval is recorded as structured data, not a checkbox in someone's head. Each review batch has a manifest with an explicit status (pending-human-review or approved), an approval record (reviewedBy, reviewedAt, notes), and a rights record. The rights status is an enum with real meaning, for example original-owned, ai-generated-commercial-use, or licensed, plus an evidence field. Reviewers work through a local review app that presents each candidate with its brief and provenance so the decision is informed.

Gating the render, not just the workflow

Here is the part that removes a whole class of bugs. The function that resolves an artwork's public lifecycle only returns a "reviewed" state when the batch manifest is approved and carries both an approval record and a rights record:

if (!manifest || manifest.status !== "approved" || !manifest.approval || !manifest.rights) {
  return placeholderLifecycle;
}

If any of those are missing, the page falls back to a clearly-marked placeholder provenance. In other words, unreviewed content structurally cannot masquerade as approved at render time. The gate is enforced in the data layer, not just in a process document someone might skip on a busy day. For a static site, this means the guarantee is baked into the build: a page cannot render a "human-reviewed" provenance claim unless the underlying manifest actually proves it.

From approved art to a printable

Once approved, the artwork is prepared as a US Letter PDF formatted for standard home printers and classroom copiers, with a descriptive title and Alt text. Alt text and titles are generated as part of the pipeline, not added later by hand, so accessibility and SEO metadata stay consistent across hundreds of pages.

Release governance in CI

The pipeline is wrapped in release governance that runs in CI:

Content validation checks that every printable's data is well-formed and consistent.
Release preflight verifies a batch is ready before it is promoted.
Lineage verification confirms a published asset traces back to an approved, hashed source.
Promotion and rollback scripts move a reviewed batch live, or reverse it cleanly if something is wrong.

The goal is that "publish" is a controlled, reversible operation with an audit trail, not a manual file copy.

The stack

Frontend: Next.js with React and TypeScript, statically generated for fast, SEO-friendly pages.
Hosting: Vercel (global CDN).
Artwork: AI generation (Seedream) plus the documented human review pipeline above.
Documents: automated US Letter PDF generation.
Analytics: GA4 with consent-aware configuration.
Quality: automated content validation and production monitoring in CI.

Static generation is a good fit here precisely because the content is governed: the build reads the review manifests and refuses to render unapproved provenance, so the guarantee travels with the generated output.

Why this matters for a kids' product

For a generic image site, an occasional odd generation is noise. For a free library that parents and teachers print for preschoolers, it is a trust problem, and trust is the whole product. The two-gate model plus manifest-gated rendering means the site can make an honest public claim — every page is AI-generated and human-reviewed — and the code enforces that claim rather than hoping the workflow was followed.

Trade-offs and lessons

Human review is the bottleneck, on purpose. It caps throughput. That is the point: the constraint is what makes the library trustworthy.
Provenance is cheap insurance. Recording a SHA-256 per source asset costs almost nothing and turns "where did this come from?" into a lookup.
Enforce gates in the data layer. A rule that lives only in a document gets skipped. A rule that lives in the render path does not.
Structured briefs beat clever prompts. Constraining the input (bold outlines, simple shapes, no tiny details) prevents more defects than any downstream fix.

If you are shipping AI-generated content into a context where quality or safety actually matters, the lesson generalizes: let the model produce volume, but put a deterministic provenance record and a mandatory human gate between generation and publication, and make the "approved" state something the code verifies, not something a person asserts.

You can see the reader-facing version of this process at EarlyHue, and the plain-language summary lives on the How our coloring pages are made page.

DEV Community: Derek Vance